AtomicReferenceArray (clase)

Una clase java.util.concurrent.atomic.AtomicReferenceArray proporciona operaciones en una matriz de referencia subyacente que se puede leer y escribir de forma atómica, y también contiene operaciones atómicas avanzadas. AtomicReferenceArray admite operaciones atómicas en la variable de matriz de referencia subyacente. Tiene métodos get y set que funcionan como lectura y escritura en variables volátiles. Es decir, un conjunto tiene una relación de suceder antes con cualquier obtención posterior de la misma variable. El método atomic compareAndSet también tiene estas características de coherencia de memoria.

Métodos AtomicReferenceArray

A continuación se muestra la lista de métodos importantes disponibles en la clase AtomicReferenceArray.

No Señor. Método y descripción
1

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

Atómicamente establece el elemento en la posición i al valor actualizado dado si el valor actual == el valor esperado.
2

public E get(int i)

Obtiene el valor actual en la posición i.
3

public E getAndSet(int i, E newValue)

Atómicamente establece el elemento en la posición i al valor dado y devuelve el valor anterior.
4

public void lazySet(int i, E newValue)

Finalmente, establece el elemento en la posición i al valor dado.
5

public int length()

Devuelve la longitud de la matriz.
6

public void set(int i, E newValue)

Establece el elemento en la posición i en el valor dado.
7

public String toString()

Devuelve la representación de cadena de los valores actuales de la matriz.
8

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

Atómicamente establece el elemento en la posición i al valor actualizado dado si el valor actual == el valor esperado.

Ejemplo

El siguiente programa TestThread muestra el uso de la variable AtomicReferenceArray en un entorno basado en subprocesos.

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

Esto producirá el siguiente resultado.

Salida

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