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

CKTIS / Java

AtomicLong : valeur initiale et incrément atomique

Fixez la valeur de départ d’un compteur partagé, récupérez chaque numéro après l’incrément et découvrez pourquoi la sentinelle `POISON` reçoit le plus petit numéro.

Version : Java SE 21

Syntaxe

import java.util.concurrent.atomic.AtomicLong;

// Constructor: public AtomicLong(long initialValue)
// Instance method: public final long incrementAndGet()
AtomicLong seq = new AtomicLong(40L);
long next = seq.incrementAndGet();

Dans Java SE 21, AtomicLong, du paquet java.util.concurrent.atomic, contient une valeur long modifiable. Le constructeur AtomicLong(long) crée un compteur avec la valeur initiale fournie ; la surcharge AtomicLong() démarre à 0. La valeur initiale n’est pas encore le premier numéro attribué.

AtomicLong.incrementAndGet est une méthode d’instance sans argument. En une seule opération atomique, elle ajoute 1 et renvoie la nouvelle valeur de type long. getAndIncrement() incrémente aussi le compteur, mais renvoie l’ancienne valeur. La lecture et l’écriture suivent la sémantique mémoire de volatile, conformément à VarHandle.getAndAdd.

Si les threads ne font qu’incrémenter la même instance, les numéros attribués sont distincts et strictement croissants dans l’ordre des mises à jour jusqu’au dépassement de capacité. Après Long.MAX_VALUE vient Long.MIN_VALUE, sans exception. Le compteur ne rend atomiques ni la construction d’un objet ni son insertion dans une file, et ne détermine pas l’ordre dans lequel les threads terminent leur travail.

Les initialiseurs des champs static de l’exemple s’exécutent dans l’ordre du code source. Le compteur partagé SEQ est créé en premier, puis la sentinelle POISON. Son constructeur effectue le premier incrément et stocke 41, le plus petit numéro de l’exemple. Les entrées ordinaires sont créées plus tard dans main.

Exemples

import java.util.concurrent.atomic.AtomicLong;

public class SequenceDemo {
    private static final AtomicLong SEQ = new AtomicLong(40L);
    private static final Entry POISON = new Entry();

    private static final class Entry {
        private final long seq;

        private Entry() {
            seq = SEQ.incrementAndGet();
        }
    }

    public static void main(String[] args) {
        Entry first = new Entry();
        Entry second = new Entry();
        System.out.println("POISON: " + POISON.seq);
        System.out.println("first: " + first.seq);
        System.out.println("second: " + second.seq);
    }
}

Résultat

POISON: 41
first: 42
second: 43

L’exemple utilise un seul thread : `40` est la valeur de départ, et `41`, `42` et `43` sont les valeurs renvoyées par les incréments successifs.

Leçons associées

  • Java · Leçon 38 · Avancé · Version : 2

Sources