Klasa AtomicReferenceArray

Klasa java.util.concurrent.atomic.AtomicReferenceArray udostępnia operacje na bazowej tablicy referencyjnej, która może być odczytywana i zapisywana atomowo, a także zawiera zaawansowane operacje atomowe. AtomicReferenceArray obsługuje niepodzielne operacje na źródłowej zmiennej tablicy referencyjnej. Posiada metody pobierania i ustawiania, które działają jak odczyty i zapisy na zmiennych zmiennych. Oznacza to, że zestaw ma relację zdarzenie przed każdym kolejnym uzyskaniem tej samej zmiennej. Atomowa metoda compareAndSet również ma te funkcje spójności pamięci.

Metody AtomicReferenceArray

Poniżej znajduje się lista ważnych metod dostępnych w klasie AtomicReferenceArray.

Sr.No.	Metoda i opis
1	public boolean compareAndSet(int i, E expect, E update) Atomowo ustawia element na pozycji i na podaną zaktualizowaną wartość, jeśli bieżąca wartość == oczekiwana wartość.
2	public E get(int i) Pobiera bieżącą wartość z pozycji i.
3	public E getAndSet(int i, E newValue) Atomowo ustawia element w pozycji i na podaną wartość i zwraca starą wartość.
4	public void lazySet(int i, E newValue) Ostatecznie ustawia element w pozycji i na podaną wartość.
5	public int length() Zwraca długość tablicy.
6	public void set(int i, E newValue) Ustawia element w pozycji i na podaną wartość.
7	public String toString() Zwraca ciąg znaków reprezentujący bieżące wartości tablicy.
8	public boolean weakCompareAndSet(int i, E expect, E update) Atomowo ustawia element na pozycji i na podaną zaktualizowaną wartość, jeśli bieżąca wartość == oczekiwana wartość.

Przykład

Poniższy program TestThread przedstawia użycie zmiennej AtomicReferenceArray w środowisku opartym na wątkach.

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

Spowoduje to następujący wynik.

Wynik

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