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

CKTIS / Java

LongAdder — comptage et somme concurrents

LongAdder accumule une somme de type long mise à jour par plusieurs threads. Il convient aux statistiques, mais sum() ne fournit pas d’instantané atomique et la remise à zéro exige de contrôler les mises à jour concurrentes.

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

Syntaxe

LongAdder counter = new LongAdder();
counter.increment();       // void
counter.add(longValue);    // void
long total = counter.sum();
long previous = counter.sumThenReset();
counter.reset();           // void

java.util.concurrent.atomic.LongAdder commence à zéro et répartit les mises à jour entre des variables internes afin de réduire la contention entre threads. En cas de forte contention, il peut offrir un débit supérieur à celui d’AtomicLong, au prix d’une consommation mémoire plus élevée. Utilisez-le pour les statistiques, et non pour contrôler précisément la synchronisation.

LongAdder.increment() ajoute un et LongAdder.add(long) ajoute la valeur fournie ; les deux méthodes renvoient void. LongAdder.sum() renvoie un long, mais ne fournit pas d’instantané atomique : des mises à jour effectuées pendant la lecture peuvent ne pas être prises en compte. En l’absence de mises à jour concurrentes, le résultat est exact.

LongAdder.reset() remet l’état à zéro et renvoie void ; utilisez cette méthode uniquement lorsqu’aucun thread ne met à jour le compteur. LongAdder.sumThenReset() renvoie la somme et remet l’état à zéro. Ne la considérez pas comme une limite atomique entre deux périodes de mesure : en présence de mises à jour concurrentes, le résultat n’est pas nécessairement la valeur finale avant la remise à zéro.

Dans l’exemple, les deux appels à join() précèdent les lectures et les remises à zéro. La sortie attendue est donc déterministe. La documentation porte sur Java SE 21 ; l’environnement d’exécution du dépôt ne permet pas d’attester celui de production.

Exemples

import java.util.concurrent.atomic.LongAdder;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        LongAdder counter = new LongAdder();
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };
        Thread first = new Thread(task);
        Thread second = new Thread(task);
        first.start();
        second.start();
        first.join();
        second.join();

        counter.add(5);
        System.out.println(counter.sum());
        System.out.println(counter.sumThenReset());
        System.out.println(counter.sum());
        counter.add(7);
        counter.reset();
        System.out.println(counter.sum());
    }
}

Résultat

2005
2005
0
0

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