Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

AtomicReference: leitura, CAS por identidade e troca

Lê a referência atual, substitui-a apenas se for idêntica à esperada, ou troca-a sem condições e recupera a configuração anterior.

Versão: Java SE 21

Sintaxe

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)

No Java SE 21, AtomicReference<V>, do pacote java.util.concurrent.atomic, guarda uma única referência, que pode ser null. AtomicReference.get() devolve a referência guardada no momento da leitura, com a semântica de uma leitura volatile. Não copia o objeto nem garante que a referência continue a ser a atual.

AtomicReference.compareAndSet(expectedValue, newValue) (CAS) compara atomicamente a referência atual com a esperada usando ==, e não equals(). Se ambas apontarem para o mesmo objeto ou forem ambas null, guarda newValue e devolve true. Caso contrário, devolve false sem escrever. A leitura tem semântica volatile; a escrita, também com semântica volatile, só ocorre se as referências coincidirem.

AtomicReference.getAndSet(newValue) guarda a nova referência sem condições e devolve a referência que substituiu, não a nova. A leitura e a escrita têm semântica volatile e formam uma única operação atómica. Chamadas separadas a get() e set() não dão essa garantia: outra thread pode alterar a referência entre as duas chamadas.

Ao substituir uma configuração imutável, usa CAS se a atualização depender da instância que leste antes. CAS verifica a identidade atual, não o histórico: não deteta A → B → A se A for a mesma referência (problema ABA). Usa getAndSet() se quiseres substituir a configuração sem condições e recuperar exatamente a que foi substituída. A atomicidade aplica-se à referência guardada, não às alterações dos campos do objeto.

Exemplos

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

Os dois objetos `Config` distintos têm o mesmo conteúdo, mas CAS só tem êxito com a referência lida. Depois, `getAndSet()` devolve a configuração `maintenance`, embora a configuração guardada já seja `recovery`.

Lições relacionadas

  • Java · Lição 55 · Intermédio · Versão: 2

Fontes