U Javi, atomske varijable i operacije korišteni istovremeno. The višenitnost okolina dovodi do problema kada konkurencija je unificiran. Zajednički entitet poput objekata i varijabli može se mijenjati tijekom izvođenja programa. Stoga mogu dovesti do nekonzistentnosti programa. Dakle, važno je voditi računa o zajedničkom entitetu dok istovremeno pristupate. U takvim slučajevima, atomska varijabla može biti rješenje za to. U ovom odjeljku ćemo raspravljati atomske klase, atomske varijable, atomske operacije , zajedno s primjerima.

c# poduka

Prije nego što krenete naprijed u ovom odjeljku, provjerite jeste li svjesni nit , sinkronizacija , i zaključati u Javi.

Java atomske klase

Java pruža a java.util.concurrent.atomic paket u kojem su definirane atomske klase. Atomske klase pružaju a bez zaključavanja i siguran za niti okruženje ili programiranje na jednoj varijabli. Također podržava atomske operacije. Sve atomske klase imaju get() i set() metode koje rade na volatile varijabli. Metoda radi isto kao čitanje i pisanje na volatile varijablama.

Paket pruža sljedeće atomske klase:

Objekti ovih klasa predstavljaju atomsku varijablu od int, long, Boolean , i objekt referenca odnosno. Atomske klase imaju neke zajedničke metode koje su sljedeće:

Atomske operacije

One operacije koje se uvijek izvode zajedno poznate su kao atomske operacije ili atomsko djelovanje . Sve atomske operacije koje se učinkovito izvrše događaju se sve odjednom ili se uopće ne dogode. Tri ključni koncepti povezani s atomskim radnjama u Javi su sljedeći:

1. Atomičnost se bavi time koje radnje i skupovi akcija imaju nevidljiv Na primjer, razmotrite sljedeći isječak koda:

 class NoAtomicOps { long counter=0; void increment() { for(;;) { count++; } } void decrement() { for(;;) { count--; } } //other statement } 

U gornjem kodu, ponašanje istovremenog pokretanja increment() i decrement() je nedefiniran i nije predvidljivo .

2. Vidljivost određuje kada može biti učinak jedne niti vidio od strane drugog. Na primjer, razmotrite sljedeći isječak koda:

koliko gradova ima u Sjedinjenim Američkim Državama

 class InfiniteLoop { boolean done= false; void work() { //thread T2 read while(!done) { //do work } } void stopWork() { //thread T1 write done=true; } //statements } 

U gornjem kodu, moguće je da se nit T2 nikad neće zaustaviti čak ni nakon što se nit T1 postavi na true. Također, nije da nema sinkronizacije između niti.

3. Redoslijed određuje kada se akcije u jednoj niti događaju izvan redoslijeda u odnosu na drugu nit.

 class Order { boolean a=false; boolean b=false; void demo1() //thread T1 { a=true; b=true; } boolean demo2() //thread T2 { boolean r1=b; //sees true boolean r2=a; //sees false boolean r3=a; //sees true //returns true return (r1 && !r2) && r3; } } 

Redoslijed pojavljivanja polja a i b u niti T2 može se razlikovati od redoslijeda koji su postavljeni u niti T1.

Shvatimo to kroz primjer.

 public class AtomicExample { int count; public void incrementCount() { count=1; } 

U gornjem isječku koda deklarirali smo varijablu tipa int računati a unutar metode incrementCount() ga je dodijelio na 1. U takvom slučaju ili se sve događa zajedno ili se ne bi dogodilo uopće. Dakle, predstavlja atomska operacija a operacija je poznata kao valentnost .

Razmotrimo još jedan isječak koda.

 public class AtomicExample { int count; public void incrementCount() { count=count+1; } 

Čini se da je i to atomska operacija, ali nije tako. To je linearna operacija koja se sastoji od tri operacije, tj. čitanja, izmjene i pisanja. Stoga se može izvršiti djelomično. Ali ako koristimo gornji kod u višenitnom okruženju, to stvara problem.

Pretpostavimo da smo gornji kod pozvali u jednonitno okruženje, ažurirana vrijednost count bit će 2. Ako gornju metodu pozovemo pomoću dvije odvojene niti, obje pristupaju varijabli u isto vrijeme i također ažuriraju vrijednost brojati istovremeno. Da bismo izbjegli ovu situaciju, koristimo atomsku operaciju.

spavati u js

Java podržava nekoliko vrsta atomskih radnji, a to su:

• Hlapljiv varijable
• Atomske operacije niske razine (nesigurne)
• Atomske klase

Pogledajmo kako možemo stvoriti atomsku operaciju.

Atomska varijabla

Atomska varijabla nam omogućuje izvođenje atomske operacije na varijabli. Atomske varijable minimiziraju sinkronizaciju i pomažu u izbjegavanju pogrešaka dosljednosti memorije. Stoga osigurava sinkronizaciju.

Atomski paket pruža sljedećih pet atomskih varijabli:

nbsp

• AtomskiInteger
• AtomicLong
• AtomicBoolean
• AtomicIntegerArray
• AtomicLongArray

Potreba za atomskom varijablom

Razmotrimo sljedeći kod.

Brojač.java

 class Counter extends Thread { // Counter Variable int count = 0; //the method starts the execution of a thread public void run() { int max = 1; //increments the counter variable up to specified max time for (int i = 0; i <max; i++) { count++; } public class counter static void main(string args[]) throws interruptedexception creating an instance of the c="new" counter(); four threads thread t1="new" thread(c, 'first'); t2="new" 'second'); t3="new" 'third'); t4="new" 'fourth'); by calling start() method, we have started t1.start(); t2.start(); t3.start(); t4.start(); main will wait for all until execution do not complete t1.join(); t2.join(); t3.join(); t4.join(); prints final value count variable system.out.println(c.count); < pre> <p> <strong>Output:</strong> </p> <pre> 4 </pre> <p>The above program gives the expected output if it is executed in a single-threaded environment. A multi-threaded environment may lead to unexpected output. The reason behind it that when two or more threads try to update the value at the same time then it may not update properly.</p> <p>Java offers <strong>two</strong> solutions to overcome this problem:</p> <ul> <li>By using lock and synchronization</li> <li>By using atomic variable</li> </ul> <p>Let&apos;s create a Java program and use an atomic variable to overcome the problem.</p> <h3>By using Atomic Variable</h3> <p> <strong>AtomicExample.java</strong> </p> <pre> class Counter extends Thread { // Counter Variable int count = 0; //the method starts the execution of a thread public void run() { int max = 1; //increments the counter variable up to specified max time for (int i = 0; i <max; i++) { count++; } public class counter static void main(string args[]) throws interruptedexception creating an instance of the c="new" counter(); four threads thread t1="new" thread(c, 'first'); t2="new" 'second'); t3="new" 'third'); t4="new" 'fourth'); by calling start() method, we have started t1.start(); t2.start(); t3.start(); t4.start(); main will wait for all until execution do not complete t1.join(); t2.join(); t3.join(); t4.join(); prints final value count variable system.out.println(c.count); < pre> <p> <strong>Output:</strong> </p> <pre> 4 </pre> <h2>Synchronized Vs. Atomic Vs. Volatile</h2> <table class="table"> <tr> <th>Synchronized</th> <th>Atomic</th> <th>Volatile</th> </tr> <tr> <td>It applies to methods only.</td> <td>It applies to variables only.</td> <td>It also applies to variables only.</td> </tr> <tr> <td>It ensures visibility along with atomicity.</td> <td>It also ensures visibility along with atomicity.</td> <td>It ensures visibility, not atomicity.</td> </tr> <tr> <td>We can&apos;t achieve the same.</td> <td>We can&apos;t achieve the same.</td> <td>It stores in RAM, so accessing volatile variables is fast. But it does not provide thread-safety and synchronization.</td> </tr> <tr> <td>It can be implemented as a synchronized block or a synchronized method.</td> <td>We can&apos;t achieve the same.</td> <td>We can&apos;t achieve the same.</td> </tr> <tr> <td>It can lock the same class object or a different class object.</td> <td>We can&apos;t achieve the same.</td> <td>We can&apos;t achieve the same.</td> </tr> </table> <hr></max;></pre></max;>

Gornji program daje očekivani izlaz ako se izvodi u jednonitnom okruženju. Okruženje s više niti može dovesti do neočekivanog rezultata. Razlog za to je što kada dvije ili više niti pokušaju ažurirati vrijednost u isto vrijeme, možda se neće pravilno ažurirati.

Java nudi dva rješenja za prevladavanje ovog problema:

• Korištenjem zaključavanja i sinkronizacije
• Korištenjem atomske varijable

Kreirajmo Java program i upotrijebimo atomsku varijablu da prevladamo problem.

Korištenjem Atomske varijable

AtomicExample.java

 class Counter extends Thread { // Counter Variable int count = 0; //the method starts the execution of a thread public void run() { int max = 1; //increments the counter variable up to specified max time for (int i = 0; i <max; i++) { count++; } public class counter static void main(string args[]) throws interruptedexception creating an instance of the c="new" counter(); four threads thread t1="new" thread(c, \'first\'); t2="new" \'second\'); t3="new" \'third\'); t4="new" \'fourth\'); by calling start() method, we have started t1.start(); t2.start(); t3.start(); t4.start(); main will wait for all until execution do not complete t1.join(); t2.join(); t3.join(); t4.join(); prints final value count variable system.out.println(c.count); < pre> <p> <strong>Output:</strong> </p> <pre> 4 </pre> <h2>Synchronized Vs. Atomic Vs. Volatile</h2> <table class="table"> <tr> <th>Synchronized</th> <th>Atomic</th> <th>Volatile</th> </tr> <tr> <td>It applies to methods only.</td> <td>It applies to variables only.</td> <td>It also applies to variables only.</td> </tr> <tr> <td>It ensures visibility along with atomicity.</td> <td>It also ensures visibility along with atomicity.</td> <td>It ensures visibility, not atomicity.</td> </tr> <tr> <td>We can&apos;t achieve the same.</td> <td>We can&apos;t achieve the same.</td> <td>It stores in RAM, so accessing volatile variables is fast. But it does not provide thread-safety and synchronization.</td> </tr> <tr> <td>It can be implemented as a synchronized block or a synchronized method.</td> <td>We can&apos;t achieve the same.</td> <td>We can&apos;t achieve the same.</td> </tr> <tr> <td>It can lock the same class object or a different class object.</td> <td>We can&apos;t achieve the same.</td> <td>We can&apos;t achieve the same.</td> </tr> </table> <hr></max;>

Sinkronizirano vs. Atomic vs. Hlapljiv