TechCodeview

Java nyelven, atomi változók és tevékenységek párhuzamosan használják. A többszálú környezet problémához vezet, amikor párhuzamosság egységes. A megosztott entitások, például objektumok és változók a program végrehajtása során változhatnak. Ezért a program következetlenségéhez vezethetnek. Ezért fontos, hogy gondoskodjunk a megosztott entitásról, miközben egyidejűleg hozzáférünk. Ilyen esetekben a atomi változó megoldás lehet rá. Ebben a részben megvitatjuk atomi osztályok, atomi változók, atomi műveletek , példákkal együtt.

reguláris kifejezés java-ban

Mielőtt továbblép ebben a részben, győződjön meg arról, hogy tisztában van a következőkkel cérna , szinkronizálás , és zár Java nyelven.

Java Atomic osztályok

Jáva biztosítja a java.util.concurrent.atomic csomag, amelyben atomi osztályok vannak meghatározva. Az atomi osztályok biztosítják a zármentes és cérnabiztos környezet vagy programozás egyetlen változón. Támogatja az atomi műveleteket is. Minden atomi osztály rendelkezik a get() és set() metódusokkal, amelyek az illékony változón működnek. A módszer ugyanúgy működik, mint az illékony változókon való olvasás és írás.

A csomag a következő atomi osztályokat tartalmazza:

Ezen osztályok objektumai az atomi változót képviselik int, hosszú, logikai , és objektum referencia illetőleg. Az atomi osztályoknak van néhány közös módszere, amelyek a következők:

Atomműveletek

Azokat a műveleteket, amelyek mindig együtt hajtódnak végre, a atomi műveletek vagy atomi cselekvés . Az összes hatékonyan végrehajtott atomi művelet egyszerre történik, vagy egyáltalán nem történik meg. Három A Java atomi műveleteihez kapcsolódó kulcsfogalmak a következők:

1. Az atomitás azzal foglalkozik, hogy mely cselekvések és cselekvések halmazai vannak láthatatlan Vegyük például a következő kódrészletet:

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

A fenti kódban az increment() és a decrement() egyidejű futtatása a következő határozatlan és nem kiszámítható .

2. A láthatóság határozza meg, hogy mikor lehet egy szál hatása látott egy másik által. Vegyük például a következő kódrészletet:

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

A fenti kódban lehetséges, hogy a T2 szál soha nem áll le, még akkor sem, ha a T1 szálat igazra állítja. Azt sem, hogy ne lenne szinkronizálás a szálak között.

3. A sorrend határozza meg, hogy az egyik szálban mikor történnek műveletek a másik szálhoz képest.

 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; } } 

Az a és b mezők megjelenési sorrendje a T2 szálban eltérhet a T1 szálban beállított sorrendtől.

tömbök java-ban

Értsük meg egy példán keresztül.

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

A fenti kódrészletben deklaráltunk egy int típusú változót számol és az incrementCount() metóduson belül 1-hez rendelte. Ebben az esetben vagy minden együtt történik, vagy egyáltalán nem. Ennélfogva egy atomi működés és a művelet ún atomos állapot .

Nézzünk egy másik kódrészletet.

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

Úgy tűnik, hogy ez is egy atomi művelet, de nem az. Ez egy lineáris művelet, amely három műveletből áll, azaz olvasásból, módosításból és írásból. Ezért részben végrehajtható. De ha a fenti kódot többszálú környezetben használjuk, az problémát okoz.

Tegyük fel, hogy a fenti kódot egyszálú környezetben hívtuk meg, a count frissített értéke 2 lesz. Ha a fenti metódust két külön szálon keresztül hívjuk, akkor mindkettő egyszerre éri el a változót, és frissíti a változó értékét is. egyszerre számolni. Ennek elkerülésére atomi műveletet alkalmazunk.

iterátor java térkép

A Java többféle atomi műveletet támogat, amelyek a következők:

• Illó változók
• Alacsony szintű atomi műveletek (nem biztonságos)
• Atomosztályok

Nézzük meg, hogyan hozhatunk létre atomi műveletet.

Atomváltozó

Az atomi változó lehetővé teszi, hogy atomi műveletet hajtsunk végre egy változón. Az atomi változók minimalizálják a szinkronizálást, és segítenek elkerülni a memória-konzisztencia hibákat. Így ez biztosítja a szinkronizálást.

Az atomcsomag a következő öt atomi változót tartalmazza:

• AtomicInteger
• AtomicLong
• AtomicBoolean
• AtomicIntegerArray
• AtomicLongArray

Az atomi változó igénye

Tekintsük a következő kódot.

Counter.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;>

A fenti program a várt kimenetet adja, ha egyszálú környezetben fut. A többszálú környezet váratlan kimenethez vezethet. Ennek az az oka, hogy amikor két vagy több szál egyszerre próbálja frissíteni az értéket, előfordulhat, hogy nem frissül megfelelően.

mikor kezdődik a q2

Java ajánlatok kettő megoldások a probléma leküzdésére:

• Zárolás és szinkronizálás segítségével
• Atomi változó használatával

Hozzunk létre egy Java programot, és használjunk atomi változót a probléma megoldására.

Az Atomic Variable használatával

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;>

Szinkronizált vs. Atom vs. Illó