Classe AtomicReferenceArray

Une classe java.util.concurrent.atomic.AtomicReferenceArray fournit des opérations sur le tableau de référence sous-jacent qui peuvent être lues et écrites de manière atomique, et contient également des opérations atomiques avancées. AtomicReferenceArray prend en charge les opérations atomiques sur la variable de tableau de référence 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 AtomicReferenceArray

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

N ° Sr. Méthode et description
1

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

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

public E get(int i)

Obtient la valeur actuelle à la position i.
3

public E getAndSet(int i, E newValue)

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

public void lazySet(int i, E newValue)

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

public int length()

Renvoie la longueur du tableau.
6

public void set(int i, E newValue)

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

public String toString()

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

public boolean weakCompareAndSet(int i, E expect, E 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 AtomicReferenceArray dans un environnement basé sur les threads.

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

Cela produira le résultat suivant.

Production

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