у Јави, атомске променљиве и операције користи се истовремено. Тхе мулти-тхреадинг окружење доводи до проблема када истовременост је уједињен. Дељени ентитет као што су објекти и променљиве може да се промени током извршавања програма. Због тога могу довести до недоследности програма. Дакле, важно је водити рачуна о дељеном ентитету док истовремено приступате. У таквим случајевима, атомска променљива може бити решење за то. У овом одељку ћемо разговарати атомске класе, атомске варијабле, атомске операције , заједно са примерима.

када се завршава к1

Пре него што кренете даље у овом одељку, уверите се да сте свесни конац , синхронизација , и закључати у Јави.

Јава атомске класе

Јава пружа а јава.утил.цонцуррент.атомиц пакет у коме су дефинисане атомске класе. Атомске класе пружају а без закључавања и потокобезопасними окружење или програмирање на једној променљивој. Такође подржава атомске операције. Све атомске класе имају методе гет() и сет() које раде на променљивој променљивој. Метода функционише исто као читање и писање на променљиве варијабле.

Пакет обезбеђује следеће атомске класе:

Објекти ових класа представљају атомску променљиву од инт, лонг, боолеан , и објекат референца редом. Атомске класе имају неке уобичајене методе као што су:

Атомске операције

Оне операције које се увек извршавају заједно познате су као атомске операције или атомско дејство . Све атомске операције се или ефикасно изврше дешавају одједном или се уопште не дешавају. Три кључни концепти повезани са атомским акцијама у Јави су следећи:

1. Атомичност се бави тиме које акције и скупови имају акције невидљиви На пример, размотрите следећи исечак кода:

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

У горњем коду, понашање покретања инцремент() и децремент() истовремено је недефинисан и није предвидљиво .

2. Видљивост одређује када може бити ефекат једне нити виђено од другог. На пример, размотрите следећи исечак кода:

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

У горњем коду, могуће је да се нит Т2 никада неће зауставити чак ни након што нит Т1 постави на труе. Такође, није да нема синхронизације између нити.

3. Редослед одређује када се акције у једној нити дешавају ван реда у односу на другу нит.

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

Редослед којим се поља а и б појављују у нити Т2 може да се разликује од редоследа којим су постављена у нити Т1.

јава тхров изузетак

Хајде да то разумемо кроз пример.

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

У горњем исечку кода, декларисали смо променљиву типа инт цоунт а унутар методе инцрементЦоунт() га је доделио 1. У таквом случају, или се све дешава заједно или се уопште неће десити. Дакле, представља ан атомска операција а операција је позната као атомичност .

Хајде да размотримо још један исечак кода.

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

Чини се да је и то атомска операција, али није тако. То је линеарна операција која се састоји од три операције, односно читања, модификације и писања. Стога, може се извршити делимично. Али ако користимо горњи код у окружењу са више нити, то ствара проблем.

Претпоставимо да смо горенаведени код позвали у једнонитном окружењу, ажурирана вредност цоунт ће бити 2. Ако позовемо горњи метод помоћу две одвојене нити, оба приступају променљивој у исто време и такође ажурирају вредност рачунати истовремено. Да бисмо избегли ову ситуацију, користимо атомску операцију.

виндовс.опен јавасцрипт

Јава подржава неколико типова атомских акција, као што су:

• Нестабилан Променљиве
• Атомске операције ниског нивоа (небезбедне)
• Атомске класе

Хајде да видимо како можемо да направимо атомску операцију.

Атомиц Вариабле

Атомска променљива нам омогућава да извршимо атомску операцију над променљивом. Атомске променљиве минимизирају синхронизацију и помажу у избегавању грешака у конзистентности меморије. Дакле, обезбеђује синхронизацију.

Атомски пакет обезбеђује следећих пет атомских варијабли:

• АтомицИнтегер
• АтомицЛонг
• АтомицБоолеан
• АтомицИнтегерАрраи
• АтомицЛонгАрраи

Потреба за атомском променљивом

Хајде да размотримо следећи код.

Цоунтер.јава

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

Горњи програм даје очекивани излаз ако се извршава у једнонитном окружењу. Окружење са више нити може довести до неочекиваног излаза. Разлог за то је тај што када две или више нити покушавају да ажурирају вредност у исто време, она се можда неће правилно ажурирати.

питхон нова линија

Јава нуди два решења за превазилажење овог проблема:

• Коришћењем закључавања и синхронизације
• Коришћењем атомске променљиве

Хајде да направимо Јава програм и користимо атомску променљиву да превазиђемо проблем.

Коришћењем атомске променљиве

АтомицЕкампле.јава

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

Синцхронизед Вс. Атомиц Вс. Нестабилан