Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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

Fonti