Concurrencia de Java - Clase AtomicLongArray

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

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

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

public long addAndGet(int i, long delta)

Agrega atómicamente el valor dado al elemento en el índice i.
2

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

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

public long decrementAndGet(int i)

Disminuye atómicamente en uno el elemento en el índice i.
4

public long get(int i)

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

public long getAndAdd(int i, long delta)

Agrega atómicamente el valor dado al elemento en el índice i.
6

public long getAndDecrement(int i)

Disminuye atómicamente en uno el elemento en el índice i.
7

public long getAndIncrement(int i)

Incrementa atómicamente en uno el elemento en el índice i.
8

public long getAndSet(int i, long newValue)

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

public long incrementAndGet(int i)

Incrementa atómicamente en uno el elemento en el índice i.
10

public void lazySet(int i, long 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, long 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, long expect, long 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.AtomicLongArray;

public class TestThread {
   private static AtomicLongArray atomicLongArray = new AtomicLongArray(10);

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

      for (int i = 0; i<atomicLongArray.length(); i++) {
         atomicLongArray.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<atomicLongArray.length(); i++) {
         System.out.print(atomicLongArray.get(i) + " ");
      }
   }  

   static class Increment implements Runnable {

      public void run() {

         for(int i = 0; i<atomicLongArray.length(); i++) {
            long add = atomicLongArray.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<atomicLongArray.length(); i++) {
            boolean swapped = atomicLongArray.compareAndSet(i, 2, 3);
            
            if(swapped) {
               System.out.println("Thread " + Thread.currentThread().getId()
                  + ", index " +i + ", value: 3");
            }
         }
      }
   }
}

Esto producirá el siguiente resultado.

Salida

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