Concurrencia de Java - Clase AtomicIntegerArray

Una clase java.util.concurrent.atomic.AtomicIntegerArray proporciona operaciones en una matriz int subyacente que se puede leer y escribir de forma atómica, y también contiene operaciones atómicas avanzadas. AtomicIntegerArray admite operaciones atómicas en la variable de matriz int 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 AtomicIntegerArray

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

No Señor.	Método y descripción
1	public int addAndGet(int i, int delta) Agrega atómicamente el valor dado al elemento en el índice i.
2	public boolean compareAndSet(int i, int expect, int update) Atómicamente establece el elemento en la posición i al valor actualizado dado si el valor actual == el valor esperado.
3	public int decrementAndGet(int i) Disminuye atómicamente en uno el elemento en el índice i.
4	public int get(int i) Obtiene el valor actual en la posición i.
5	public int getAndAdd(int i, int delta) Agrega atómicamente el valor dado al elemento en el índice i.
6	public int getAndDecrement(int i) Disminuye atómicamente en uno el elemento en el índice i.
7	public int getAndIncrement(int i) Incrementa atómicamente en uno el elemento en el índice i.
8	public int getAndSet(int i, int newValue) Atómicamente establece el elemento en la posición i al valor dado y devuelve el valor anterior.
9	public int incrementAndGet(int i) Incrementa atómicamente en uno el elemento en el índice i.
10	public void lazySet(int i, int newValue) Finalmente, establece el elemento en la posición i al valor dado.
11	public int length() Devuelve la longitud de la matriz.
12	public void set(int i, int newValue) Establece el elemento en la posición i en el valor dado.
13	public String toString() Devuelve la representación de cadena de los valores actuales de la matriz.
14	public boolean weakCompareAndSet(int i, int expect, int 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 AtomicIntegerArray en un entorno basado en subprocesos.

import java.util.concurrent.atomic.AtomicIntegerArray;

public class TestThread {
   private static AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(10);

   public static void main(final String[] arguments) throws InterruptedException {
      
      for (int i = 0; i<atomicIntegerArray.length(); i++) {
         atomicIntegerArray.set(i, 1);
      }

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

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

      System.out.println("Values: ");

      for (int i = 0; i<atomicIntegerArray.length(); i++) {
         System.out.print(atomicIntegerArray.get(i) + " ");
      }
   }

   static class Increment implements Runnable {

      public void run() {

         for(int i = 0; i<atomicIntegerArray.length(); i++) {
            int add = atomicIntegerArray.incrementAndGet(i);
            System.out.println("Thread " + Thread.currentThread().getId() 
               + ", index " +i + ", value: "+ add);
         }
      }
   }

   static class Compare implements Runnable {

      public void run() {

         for(int i = 0; i<atomicIntegerArray.length(); i++) {
            boolean swapped = atomicIntegerArray.compareAndSet(i, 2, 3);
            
            if(swapped) {
               System.out.println("Thread " + Thread.currentThread().getId()
                  + ", index " +i + ", value: 3");
            }
         }
      }
   }
}

Esto producirá el siguiente resultado.

Salida

Thread 10, index 0, value: 2
Thread 10, index 1, value: 2
Thread 10, index 2, value: 2
Thread 11, index 0, value: 3
Thread 10, index 3, value: 2
Thread 11, index 1, value: 3
Thread 11, index 2, value: 3
Thread 10, index 4, value: 2
Thread 11, index 3, value: 3
Thread 10, index 5, value: 2
Thread 10, index 6, value: 2
Thread 11, index 4, value: 3
Thread 10, index 7, value: 2
Thread 11, index 5, value: 3
Thread 10, index 8, value: 2
Thread 11, index 6, value: 3
Thread 10, index 9, value: 2
Thread 11, index 7, value: 3
Thread 11, index 8, value: 3
Thread 11, index 9, value: 3
Values:
3 3 3 3 3 3 3 3 3 3