TechCodeview

Java'da, atomik değişkenler Ve operasyonlar eşzamanlı olarak kullanılır. çoklu iş parçacığı ortam soruna yol açtığında eşzamanlılık birleşiktir. Nesneler ve değişkenler gibi paylaşılan varlıklar programın yürütülmesi sırasında değiştirilebilir. Dolayısıyla programın tutarsızlığına yol açabilirler. Bu nedenle, eşzamanlı erişim sırasında paylaşılan varlığa dikkat etmek önemlidir. Bu gibi durumlarda, atomik değişken buna bir çözüm olabilir. Bu bölümde tartışacağız atom sınıfları, atom değişkenleri, atomik işlemler , örneklerle birlikte.

np.random.rand

Bu bölümde ilerlemeden önce aşağıdaki hususların farkında olduğunuzdan emin olun: iplik , senkronizasyon , Ve kilit Java'da.

Java Atom Sınıfları

Java sağlar java.util.concurrent.atomic Atomik sınıfların tanımlandığı paket. Atom sınıfları şunları sağlar: kilitsiz Ve iplik güvenli tek bir değişken üzerinde ortam veya programlama. Aynı zamanda atomik işlemleri de destekler. Tüm atom sınıfları, uçucu değişken üzerinde çalışan get() ve set() yöntemlerine sahiptir. Yöntem, uçucu değişkenler üzerinde okuma ve yazma ile aynı şekilde çalışır.

Paket aşağıdaki atomik sınıfları sağlar:

Bu sınıfların nesneleri atomik değişkeni temsil eder. int, uzun, boolean ve nesne referans sırasıyla. Atomik sınıfların bazı ortak yöntemleri vardır:

Atomik İşlemler

Her zaman birlikte yürütülen işlemlere denir. atom operasyonları veya atom eylemi . Etkin bir şekilde yürütülen tüm atomik işlemler ya bir anda gerçekleşir ya da hiç gerçekleşmez. Üç Java'daki atomik eylemlerle ilişkili temel kavramlar aşağıdaki gibidir:

1. Atomiklik, hangi eylemlerin ve eylem kümelerinin sahip olduğuyla ilgilenir. görünmez Örneğin aşağıdaki kod parçacığını göz önünde bulundurun:

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

Yukarıdaki kodda, Increment() ve Decrement() işlevlerini aynı anda çalıştırmanın davranışı şöyledir: Tanımsız Ve tahmin edilemez .

2. Görünürlük, bir iş parçacığının etkisinin ne zaman olabileceğini belirler görülen başka biri. Örneğin aşağıdaki kod parçacığını göz önünde bulundurun:

kabuk komut dosyasındaki for döngüsü

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

Yukarıdaki kodda, T1 iş parçacığının doğru olarak ayarlanmasından sonra bile T2 iş parçacığının asla durmaması mümkündür. Ayrıca iş parçacıkları arasında senkronizasyon olmadığı da söylenemez.

3. Sıralama, bir iş parçacığında yapılan eylemlerin başka bir iş parçacığına göre sıra dışı gerçekleştiğini belirler.

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

a ve b alanlarının T2 iş parçacığında görünme sırası, T1 iş parçacığında ayarlanan sıradan farklı olabilir.

Bir örnek üzerinden anlayalım.

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

Yukarıdaki kod parçasında int türünde bir değişken tanımladık. saymak ve IncrementCount() yönteminin içinde bunu 1'e atadık. Böyle bir durumda ya hepsi birlikte olur ya da hiç olmaz. Dolayısıyla bir temsil eder atomik operasyon ve operasyon şu şekilde bilinir: atomiklik .

Başka bir kod parçacığını ele alalım.

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

Görünüşe göre bu da atomik bir operasyon ama öyle değil. Okuma, değiştirme ve yazma gibi üç işlemden oluşan doğrusal bir işlemdir. Bu nedenle kısmen yürütülebilir. Ancak yukarıdaki kodu çok iş parçacıklı bir ortamda kullanıyorsak, bu bir sorun yaratır.

Yukarıdaki kodu tek iş parçacıklı bir ortamda çağırdığımızı varsayalım, count'un güncellenen değeri 2 olacaktır. Yukarıdaki yöntemi iki ayrı iş parçacığı tarafından çağırırsak, ikisi de değişkene aynı anda erişir ve aynı zamanda değerini de günceller. aynı anda sayın. Bu durumu önlemek için atomik işlemi kullanıyoruz.

mark zuckerberg eğitimi

Java çeşitli atomik eylem türlerini destekler; bunlar aşağıdaki gibidir:

• Uçucu değişkenler
• Düşük seviyeli atomik işlemler (güvenli değil)
• Atom sınıfları

Bakalım atomik bir operasyonu nasıl oluşturacağız.

j e s t

Atomik Değişken

Atomik değişken, bir değişken üzerinde atomik işlem yapmamızı sağlar. Atomik değişkenler senkronizasyonu en aza indirir ve bellek tutarlılığı hatalarından kaçınmaya yardımcı olur. Dolayısıyla senkronizasyonu sağlar.

Atom paketi aşağıdaki beş atomik değişkeni sağlar:

• AtomikTamsayı
• AtomikUzun
• AtomikBoolean
• AtomicIntegerArray
• AtomicLongArray

Atomik Değişken İhtiyacı

Aşağıdaki kodu ele alalım.

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

Yukarıdaki program, tek iş parçacıklı bir ortamda yürütülürse beklenen çıktıyı verir. Çok iş parçacıklı bir ortam beklenmeyen çıktılara yol açabilir. Bunun nedeni, iki veya daha fazla iş parçacığının değeri aynı anda güncellemeye çalışması durumunda düzgün şekilde güncellenmemesidir.

Java teklifleri iki bu sorunun üstesinden gelmek için çözümler:

• Kilit ve senkronizasyonu kullanarak
• Atomik değişkeni kullanarak

Sorunun üstesinden gelmek için bir Java programı oluşturalım ve atomik bir değişken kullanalım.

Atomik Değişkeni Kullanarak

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

Senkronize Vs. Atomik Vs. Uçucu