Concurrence Java - Classe AtomicIntegerArray

Une classe java.util.concurrent.atomic.AtomicIntegerArray fournit des opérations sur le tableau int sous-jacent qui peuvent être lues et écrites de manière atomique, et contient également des opérations atomiques avancées. AtomicIntegerArray prend en charge les opérations atomiques sur la variable de tableau int sous-jacente. Il a des méthodes get et set qui fonctionnent comme des lectures et des écritures sur des variables volatiles. Autrement dit, un ensemble a une relation qui se produit avant avec tout get ultérieur sur la même variable. La méthode atomic compareAndSet possède également ces fonctionnalités de cohérence de mémoire.

Méthodes AtomicIntegerArray

Voici la liste des méthodes importantes disponibles dans la classe AtomicIntegerArray.

N ° Sr. Méthode et description
1

public int addAndGet(int i, int delta)

Ajoute atomiquement la valeur donnée à l'élément à l'index i.
2

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

Définit atomiquement l'élément à la position i à la valeur mise à jour donnée si la valeur actuelle == la valeur attendue.
3

public int decrementAndGet(int i)

Décrémente atomiquement de un l'élément à l'index i.
4

public int get(int i)

Obtient la valeur actuelle à la position i.
5

public int getAndAdd(int i, int delta)

Ajoute atomiquement la valeur donnée à l'élément à l'index i.
6

public int getAndDecrement(int i)

Décrémente atomiquement de un l'élément à l'index i.
sept

public int getAndIncrement(int i)

Incrémente atomiquement de un l'élément à l'index i.
8

public int getAndSet(int i, int newValue)

Définit atomiquement l'élément à la position i à la valeur donnée et renvoie l'ancienne valeur.
9

public int incrementAndGet(int i)

Incrémente atomiquement de un l'élément à l'index i.
dix

public void lazySet(int i, int newValue)

Définit finalement l'élément à la position i à la valeur donnée.
11

public int length()

Renvoie la longueur du tableau.
12

public void set(int i, int newValue)

Définit l'élément à la position i à la valeur donnée.
13

public String toString()

Renvoie la représentation String des valeurs actuelles du tableau.
14

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

Définit atomiquement l'élément à la position i à la valeur mise à jour donnée si la valeur actuelle == la valeur attendue.

Exemple

Le programme TestThread suivant montre l'utilisation de la variable AtomicIntegerArray dans un environnement basé sur les threads.

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

Cela produira le résultat suivant.

Production

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