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

CKTIS / Java

AtomicInteger : lire, incrémenter, remettre à zéro et réessayer avec CAS

Initialisez un compteur atomique, lisez ou remplacez sa valeur et incrémentez-la en une seule opération. Utilisez une boucle CAS pour retenter une mise à jour conditionnelle.

Version : Java SE 21

Syntaxe

import java.util.concurrent.atomic.AtomicInteger;

AtomicInteger counter = new AtomicInteger(initialValue);
int current = counter.get();
boolean changed = counter.compareAndSet(expectedValue, newValue);
int updated = counter.incrementAndGet();
counter.set(newValue);

// initialValue, expectedValue, and newValue are int values.

AtomicInteger, dans java.util.concurrent.atomic, contient une valeur modifiable de type int. Le constructeur AtomicInteger(int) fixe la valeur initiale. get() renvoie le int courant sans le modifier. set(int newValue) remplace la valeur sans condition et ne renvoie rien (void). Ces méthodes ont respectivement la sémantique d’une lecture et d’une écriture volatile. set(0) remet le même compteur à zéro.

incrementAndGet() ajoute 1 de façon atomique et renvoie le nouveau int ; getAndIncrement() renvoie la valeur précédente. Pour une simple incrémentation, utilisez incrementAndGet() plutôt que set(get() + 1) : une autre mise à jour peut se produire entre la lecture et l’écriture, puis être écrasée. Une lecture suivie d’une remise à zéro n’est pas non plus une seule opération atomique.

compareAndSet(int expectedValue, int newValue) vérifie de façon atomique si la valeur courante est égale à expectedValue. Si oui, la méthode écrit newValue et renvoie true ; sinon, elle renvoie false sans écrire. Dans une boucle CAS écrite à la main, lisez avec get(), calculez la nouvelle valeur, puis appelez compareAndSet. Si le résultat est false, relisez et recalculez avant de réessayer ; s’il est true, quittez la boucle. CAS vérifie la valeur courante, pas l’historique de ses changements.

Exemples

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicCounterDemo {
    public static void main(String[] args) {
        AtomicInteger counter = new AtomicInteger(0);
        for (int i = 0; i < 3; i++) {
            counter.incrementAndGet();
        }
        System.out.println(counter.get());

        counter.set(0);
        int expected = counter.get();
        System.out.println(expected);
        for (int i = 0; i < 5; i++) {
            counter.incrementAndGet();
        }
        System.out.println(counter.get());

        // The first CAS still expects the value read just after the reset.
        while (!counter.compareAndSet(expected, expected + 2)) {
            System.out.println("CAS retry");
            expected = counter.get();
        }
        System.out.println(counter.get());
    }
}

Résultat

3
0
5
CAS retry
7

Le compteur passe par `0 → 3 → 0 → 5`. La première tentative CAS attend `0` mais trouve `5`, d’où l’affichage de `CAS retry`. Après une nouvelle lecture, CAS écrit `7`. Tout s’exécute dans un seul thread.

Leçons associées

  • Java · Leçon 32 · Avancé · Version : 2
  • Java · Leçon 55 · Intermédiaire · Version : 2

Sources