Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

AtomicReference: lectura, CAS por identidad e intercambio

Lee la referencia actual, sustitúyela solo si es idéntica a la esperada o cámbiala sin condiciones y recupera la configuración anterior.

Versión: Java SE 21

Sintaxis

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)

En Java SE 21, AtomicReference<V>, del paquete java.util.concurrent.atomic, almacena una sola referencia, que puede ser null. AtomicReference.get() devuelve la referencia almacenada en el momento de la lectura, con semántica de lectura volatile. No copia el objeto ni garantiza que la referencia siga siendo la actual.

AtomicReference.compareAndSet(expectedValue, newValue) (CAS) compara atómicamente la referencia actual con la esperada mediante ==, no mediante equals(). Si ambas apuntan al mismo objeto o ambas son null, guarda newValue y devuelve true. En caso contrario, devuelve false sin escribir. La lectura tiene semántica volatile; la escritura, también con semántica volatile, solo se produce si las referencias coinciden.

AtomicReference.getAndSet(newValue) guarda la referencia nueva sin condiciones y devuelve la que acaba de sustituir, no la nueva. La lectura y la escritura tienen semántica volatile y forman una sola operación atómica. Las llamadas separadas a get() y set() no ofrecen esa garantía: otro hilo puede cambiar la referencia entre ambas.

Al sustituir una configuración inmutable, usa CAS si la actualización depende de la instancia que leíste antes. CAS comprueba la identidad actual, no el historial: no detecta A → B → A si A es la misma referencia (problema ABA). Usa getAndSet() si quieres sustituir la configuración sin condiciones y recuperar exactamente la que desplazas. La atomicidad se aplica a la referencia almacenada, no a los cambios en los campos del objeto.

Ejemplos

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

Resultado

Equal contents: true
CAS with distinct object: false
CAS with observed reference: true
Previous mode: maintenance
Current mode: recovery

Los dos objetos `Config` distintos tienen el mismo contenido, pero CAS solo tiene éxito con la referencia leída. Después, `getAndSet()` devuelve la configuración `maintenance`, aunque ahora esté almacenada `recovery`.

Lecciones relacionadas

  • Java · Lección 55 · Intermedio · Versión: 2

Fuentes