CKTIS / Java
AtomicReference: lettura, CAS per identità e scambio
Leggi il riferimento corrente, sostituiscilo solo se è identico a quello atteso oppure sostituiscilo senza condizioni e recupera la configurazione precedente.
Versione: Java SE 21
Sintassi
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)In Java SE 21, AtomicReference<V> del package java.util.concurrent.atomic contiene un singolo riferimento, che può essere null. AtomicReference.get() restituisce il riferimento memorizzato al momento della lettura, con la semantica di una lettura volatile. Non copia l’oggetto e non garantisce che quel riferimento rimanga quello corrente.
AtomicReference.compareAndSet(expectedValue, newValue) (CAS) confronta atomicamente il riferimento corrente con quello atteso usando ==, non equals(). Se entrambi indicano lo stesso oggetto o sono entrambi null, memorizza newValue e restituisce true. Altrimenti restituisce false senza scrivere. La lettura ha semantica volatile; la scrittura, anch’essa con semantica volatile, avviene solo se i riferimenti coincidono.
AtomicReference.getAndSet(newValue) memorizza il nuovo riferimento senza condizioni e restituisce quello sostituito, non quello nuovo. La lettura e la scrittura hanno semantica volatile e formano un’unica operazione atomica. Due chiamate separate a get() e set() non offrono questa garanzia: un altro thread può cambiare il riferimento tra le due.
Per sostituire una configurazione immutabile, usa CAS se l’aggiornamento dipende dall’istanza letta in precedenza. CAS verifica l’identità corrente, non la cronologia: non rileva A → B → A se A è lo stesso riferimento (problema ABA). Usa getAndSet() se vuoi sostituire la configurazione senza condizioni e recuperare esattamente quella sostituita. L’atomicità riguarda il riferimento memorizzato, non le modifiche ai campi dell’oggetto.
Esempi
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());
}
}Risultato
Equal contents: true CAS with distinct object: false CAS with observed reference: true Previous mode: maintenance Current mode: recovery
I due oggetti `Config` distinti hanno lo stesso contenuto, ma CAS riesce solo con il riferimento letto. Poi `getAndSet()` restituisce la configurazione `maintenance`, anche se ora è memorizzata `recovery`.
Lezioni correlate
- Java · Lezione 55 · Intermedio · Versione: 2