AtomicReferenceArray Classe

Una classe java.util.concurrent.atomic.AtomicReferenceArray fornisce operazioni sulla matrice di riferimento sottostante che possono essere lette e scritte atomicamente e contiene anche operazioni atomiche avanzate. AtomicReferenceArray supporta operazioni atomiche sulla variabile della matrice di riferimento sottostante. Ha metodi get e set che funzionano come letture e scritture su variabili volatili. Cioè, un insieme ha una relazione accade prima con qualsiasi successivo get sulla stessa variabile. Anche il metodo compareAndSet atomico ha queste caratteristiche di coerenza della memoria.

Metodi AtomicReferenceArray

Di seguito è riportato l'elenco dei metodi importanti disponibili nella classe AtomicReferenceArray.

Sr.No. Metodo e descrizione
1

public boolean compareAndSet(int i, E expect, E update)

Atomicamente imposta l'elemento nella posizione i al valore aggiornato dato se il valore corrente == il valore atteso.
2

public E get(int i)

Ottiene il valore corrente nella posizione i.
3

public E getAndSet(int i, E newValue)

Atomicamente imposta l'elemento nella posizione i al valore dato e restituisce il vecchio valore.
4

public void lazySet(int i, E newValue)

Alla fine imposta l'elemento in posizione i al valore dato.
5

public int length()

Restituisce la lunghezza della matrice.
6

public void set(int i, E newValue)

Imposta l'elemento in posizione i sul valore dato.
7

public String toString()

Restituisce la rappresentazione String dei valori correnti di array.
8

public boolean weakCompareAndSet(int i, E expect, E update)

Atomicamente imposta l'elemento nella posizione i al valore aggiornato dato se il valore corrente == il valore atteso.

Esempio

Il seguente programma TestThread mostra l'utilizzo della variabile AtomicReferenceArray in un ambiente basato su thread.

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

Questo produrrà il seguente risultato.

Produzione

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