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

CKTIS / Java

AtomicIntegerFieldUpdater — mises à jour atomiques d’un champ int

AtomicIntegerFieldUpdater fournit des opérations atomiques sur le champ volatile int d’un objet existant. Un même updater peut servir pour plusieurs instances d’une classe, sans créer un objet AtomicInteger distinct pour chaque champ.

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

Syntaxe

AtomicIntegerFieldUpdater<T> updater = AtomicIntegerFieldUpdater.newUpdater(targetClass, "fieldName"); // targetClass is a Class<T>
int current = updater.get(obj);
boolean changed = updater.compareAndSet(obj, expect, update);

AtomicIntegerFieldUpdater<T> du package java.util.concurrent.atomic agit sur un champ volatile int sélectionné d’objets de type T. La valeur reste dans l’objet, et l’updater peut être partagé entre plusieurs instances. Ces utilitaires permettent notamment de mettre à jour indépendamment des champs dans des structures de données concurrentes.

AtomicIntegerFieldUpdater.newUpdater(targetClass, "fieldName") associe un updater à un champ. L’argument targetClass est une valeur de type Class<T>. Le champ doit être un volatile int non statique et accessible, selon les règles d’accès de Java, au code qui crée l’updater. Une déclaration, un nom ou un accès incorrect provoque une exception lors de sa création.

get et compareAndSet sont des méthodes d’instance que l’on appelle sur l’updater. updater.get(obj) lit le champ. updater.compareAndSet(obj, expect, update) écrit update uniquement si la valeur actuelle est == expect ; la méthode renvoie true en cas de réussite et false en cas de différence. Une lecture suivie d’une écriture séparée ne remplace pas cette opération.

La garantie d’atomicité couvre les appels à compareAndSet et set du même updater, et non toute autre modification du champ. Évitez donc de combiner différents mécanismes de mise à jour pour un état partagé. L’exemple à un seul thread montre une modification réussie et une modification refusée ; ce n’est pas un test de correction en contexte concurrent.

Exemples

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class Main {
    private volatile int state = 0;
    private static final AtomicIntegerFieldUpdater<Main> STATE =
            AtomicIntegerFieldUpdater.newUpdater(Main.class, "state");

    public static void main(String[] args) {
        Main item = new Main();
        System.out.println(STATE.get(item));
        System.out.println(STATE.compareAndSet(item, 0, 1));
        System.out.println(STATE.compareAndSet(item, 0, 2));
        System.out.println(STATE.get(item));
    }
}

Résultat

0
true
false
1

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