Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

AtomicReference — mettre à jour une référence de façon atomique

AtomicReference<V> fournit des opérations atomiques sur une seule référence. Découvrez les différences entre get(), le remplacement conditionnel avec compareAndSet() et le remplacement inconditionnel avec getAndSet(), ainsi que le rôle de l’identité des objets, plutôt que de l’égalité de leur contenu, dans la réussite d’un remplacement conditionnel.

Version : Java SE 21; repository runtime, production runtime not attested

Syntaxe

AtomicReference<V> ref = new AtomicReference<>(initialValue);
V current = ref.get();
boolean changed = ref.compareAndSet(expectedValue, newValue);
V previous = ref.getAndSet(newValue);

AtomicReference<V> du paquet java.util.concurrent.atomic contient une référence unique qui peut être mise à jour de façon atomique. Il protège les opérations sur la référence, pas les champs de l’objet référencé ; il ne rend pas automatiquement cet objet sûr pour une utilisation concurrente.

AtomicReference.get() lit la référence avec la sémantique de lecture volatile. AtomicReference.compareAndSet(expectedValue, newValue) compare et remplace de façon atomique : il utilise ==, et non equals(). Il renvoie true après le remplacement, ou false en cas de différence, sans modifier la valeur.

AtomicReference.getAndSet(newValue) remplace la référence de façon atomique et inconditionnelle, puis renvoie la référence précédente. Des appels distincts à get() et à l’écriture ne constituent pas une seule opération atomique ; un autre thread peut intervenir entre les deux.

L’exemple utilise un seul thread pour obtenir un résultat déterministe. Deux objets new String("ready") ont le même contenu, mais des identités différentes : la première comparaison échoue, tandis que la seconde utilise la référence stockée et réussit. Périmètre de la documentation : Java SE 21 ; l’environnement d’exécution du dépôt et celui de production ne sont pas attestés.

Exemples

import java.util.concurrent.atomic.AtomicReference;

public class Main {
    public static void main(String[] args) {
        String initial = new String("ready");
        AtomicReference<String> ref = new AtomicReference<>(initial);

        System.out.println(ref.get());
        System.out.println(ref.compareAndSet(new String("ready"), "wrong"));
        System.out.println(ref.compareAndSet(initial, "running"));
        System.out.println(ref.getAndSet("done"));
        System.out.println(ref.get());
    }
}

Résultat

ready
false
true
running
done

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources