AtomicReferenceArray-Klasse

Eine java.util.concurrent.atomic.AtomicReferenceArray-Klasse bietet Operationen für das zugrunde liegende Referenzarray, die atomar gelesen und geschrieben werden können, und enthält auch erweiterte atomare Operationen. AtomicReferenceArray unterstützt atomare Operationen für zugrunde liegende Referenzarrayvariablen. Es verfügt über Methoden zum Abrufen und Festlegen, die wie das Lesen und Schreiben flüchtiger Variablen funktionieren. Das heißt, eine Menge hat eine Vorher-Beziehung zu einem nachfolgenden Abruf derselben Variablen. Die atomare compareAndSet-Methode verfügt auch über diese Speicherkonsistenzfunktionen.

AtomicReferenceArray-Methoden

Im Folgenden finden Sie eine Liste wichtiger Methoden, die in der AtomicReferenceArray-Klasse verfügbar sind.

Sr.Nr.	Methode & Beschreibung
1	public boolean compareAndSet(int i, E expect, E update) Setzt das Element an Position i atomar auf den angegebenen aktualisierten Wert, wenn der aktuelle Wert == der erwartete Wert ist.
2	public E get(int i) Ruft den aktuellen Wert an Position i ab.
3	public E getAndSet(int i, E newValue) Setzt das Element an Position i atomar auf den angegebenen Wert und gibt den alten Wert zurück.
4	public void lazySet(int i, E newValue) Setzt das Element schließlich an Position i auf den angegebenen Wert.
5	public int length() Gibt die Länge des Arrays zurück.
6	public void set(int i, E newValue) Setzt das Element an Position i auf den angegebenen Wert.
7	public String toString() Gibt die String-Darstellung der aktuellen Werte des Arrays zurück.
8	public boolean weakCompareAndSet(int i, E expect, E update) Setzt das Element an Position i atomar auf den angegebenen aktualisierten Wert, wenn der aktuelle Wert == der erwartete Wert ist.

Beispiel

Das folgende TestThread-Programm zeigt die Verwendung der AtomicReferenceArray-Variablen in einer threadbasierten Umgebung.

import java.util.concurrent.atomic.AtomicReferenceArray;

public class TestThread {
   private static String[] source = new String[10];
   private static AtomicReferenceArray<String> atomicReferenceArray 
      = new AtomicReferenceArray<String>(source);

   public static void main(final String[] arguments) throws InterruptedException {

      for (int i = 0; i<atomicReferenceArray.length(); i++) {
         atomicReferenceArray.set(i, "item-2");
      }

      Thread t1 = new Thread(new Increment());
      Thread t2 = new Thread(new Compare());
      t1.start();
      t2.start();

      t1.join();
      t2.join();		
   }  

   static class Increment implements Runnable {
      
      public void run() {
         
         for(int i = 0; i<atomicReferenceArray.length(); i++) {
            String add = atomicReferenceArray.getAndSet(i,"item-"+ (i+1));
            System.out.println("Thread " + Thread.currentThread().getId() 
               + ", index " +i + ", value: "+ add);
         }
      }
   }

   static class Compare implements Runnable {
      
      public void run() {
         
         for(int i = 0; i<atomicReferenceArray.length(); i++) {
            System.out.println("Thread " + Thread.currentThread().getId() 
               + ", index " +i + ", value: "+ atomicReferenceArray.get(i));
            boolean swapped = atomicReferenceArray.compareAndSet(i, "item-2", "updated-item-2");
            System.out.println("Item swapped: " + swapped);
            
            if(swapped) {
               System.out.println("Thread " + Thread.currentThread().getId() 
                  + ", index " +i + ", updated-item-2");
            }
         }
      }
   }
}

Dies führt zu folgendem Ergebnis.

Ausgabe

Thread 9, index 0, value: item-2
Thread 10, index 0, value: item-1
Item swapped: false
Thread 10, index 1, value: item-2
Item swapped: true
Thread 9, index 1, value: updated-item-2
Thread 10, index 1, updated-item-2
Thread 10, index 2, value: item-3
Item swapped: false
Thread 10, index 3, value: item-2
Item swapped: true
Thread 10, index 3, updated-item-2
Thread 10, index 4, value: item-2
Item swapped: true
Thread 10, index 4, updated-item-2
Thread 10, index 5, value: item-2
Item swapped: true
Thread 10, index 5, updated-item-2
Thread 10, index 6, value: item-2
Thread 9, index 2, value: item-2
Item swapped: true
Thread 9, index 3, value: updated-item-2
Thread 10, index 6, updated-item-2
Thread 10, index 7, value: item-2
Thread 9, index 4, value: updated-item-2
Item swapped: true
Thread 9, index 5, value: updated-item-2
Thread 10, index 7, updated-item-2
Thread 9, index 6, value: updated-item-2
Thread 10, index 8, value: item-2
Thread 9, index 7, value: updated-item-2
Item swapped: true
Thread 9, index 8, value: updated-item-2
Thread 10, index 8, updated-item-2
Thread 9, index 9, value: item-2
Thread 10, index 9, value: item-10
Item swapped: false