CKTIS / Java
AtomicReference : lecture, CAS par identité et échange
Lisez la référence courante, remplacez-la seulement si elle est identique à celle attendue, ou échangez-la sans condition en récupérant la configuration précédente.
Version : Java SE 21
Syntaxe
import java.util.concurrent.atomic.AtomicReference;
// Methods of AtomicReference<V> in Java SE 21:
public final V get()
public final boolean compareAndSet(V expectedValue, V newValue)
public final V getAndSet(V newValue)Dans Java SE 21, AtomicReference<V>, du paquet java.util.concurrent.atomic, contient une seule référence, qui peut valoir null. AtomicReference.get() renvoie la référence stockée au moment de la lecture, avec la sémantique d’une lecture volatile. Cette méthode ne copie pas l’objet et ne garantit pas que la référence restera la référence courante.
AtomicReference.compareAndSet(expectedValue, newValue) (CAS) compare atomiquement la référence courante à celle attendue avec ==, et non avec equals(). Si les deux désignent le même objet ou valent toutes deux null, la méthode stocke newValue et renvoie true. Sinon, elle renvoie false sans écrire. La lecture a une sémantique volatile ; l’écriture, elle aussi volatile, n’a lieu que si les références correspondent.
AtomicReference.getAndSet(newValue) stocke la nouvelle référence sans condition et renvoie celle qu’elle a remplacée, pas la nouvelle. La lecture et l’écriture ont une sémantique volatile et forment une seule opération atomique. Des appels séparés à get() et set() n’offrent pas cette garantie : un autre thread peut modifier la référence entre les deux.
Pour remplacer une configuration immuable, utilisez CAS si la mise à jour dépend de l’instance lue auparavant. CAS vérifie l’identité courante, pas l’historique : il ne détecte pas A → B → A si A est la même référence (problème ABA). Utilisez getAndSet() pour remplacer la configuration sans condition et récupérer exactement celle qui a été remplacée. L’atomicité concerne la référence stockée, pas les modifications des champs de l’objet.
Exemples
import java.util.concurrent.atomic.AtomicReference;
public class Main {
record Config(String mode) {}
public static void main(String[] args) {
var ref = new AtomicReference<>(new Config("normal"));
Config observed = ref.get();
Config equalButDistinct = new Config("normal");
Config maintenance = new Config("maintenance");
System.out.println("Equal contents: " + observed.equals(equalButDistinct));
System.out.println("CAS with distinct object: " + ref.compareAndSet(equalButDistinct, maintenance));
System.out.println("CAS with observed reference: " + ref.compareAndSet(observed, maintenance));
Config previous = ref.getAndSet(new Config("recovery"));
System.out.println("Previous mode: " + previous.mode());
System.out.println("Current mode: " + ref.get().mode());
}
}Résultat
Equal contents: true CAS with distinct object: false CAS with observed reference: true Previous mode: maintenance Current mode: recovery
Les deux objets `Config` distincts ont le même contenu, mais le CAS ne réussit qu’avec la référence lue. Ensuite, `getAndSet()` renvoie la configuration `maintenance` alors que la référence stockée désigne désormais `recovery`.
Leçons associées
- Java · Leçon 55 · Intermédiaire · Version : 2