WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

LongAdder — nebenläufiges Zählen und Summieren

LongAdder sammelt eine von mehreren Threads aktualisierte Summe vom Typ long. Es eignet sich für Statistiken, aber sum() liefert keinen atomaren Schnappschuss, und zum Zurücksetzen müssen nebenläufige Aktualisierungen kontrolliert werden.

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

Syntax

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 beginnt bei null und verteilt Aktualisierungen auf interne Variablen, um die Konkurrenz zwischen Threads zu verringern. Bei hoher Konkurrenz kann es einen höheren Durchsatz als AtomicLong bieten, allerdings auf Kosten des Speicherbedarfs. Verwenden Sie es für Statistiken, nicht für eine präzise Steuerung der Synchronisierung.

LongAdder.increment() addiert eins und LongAdder.add(long) den angegebenen Wert; beide Methoden geben void zurück. LongAdder.sum() gibt einen long zurück, liefert aber keinen atomaren Schnappschuss: Aktualisierungen, die während des Lesens stattfinden, können unberücksichtigt bleiben. Ohne nebenläufige Aktualisierungen ist das Ergebnis genau.

LongAdder.reset() setzt den Zustand zurück und gibt void zurück; verwenden Sie die Methode nur, wenn kein Thread den Zähler aktualisiert. LongAdder.sumThenReset() gibt die Summe zurück und setzt den Zustand zurück. Betrachten Sie die Methode nicht als atomare Grenze eines Messzeitraums: Bei nebenläufigen Aktualisierungen muss das Ergebnis nicht dem endgültigen Wert vor dem Zurücksetzen entsprechen.

Im Beispiel erfolgen beide Aufrufe von join() vor dem Lesen und Zurücksetzen. Dadurch ist die erwartete Ausgabe deterministisch. Der Dokumentationsumfang ist Java SE 21; die Laufzeitumgebung des Repositorys bestätigt nicht die Produktionslaufzeit.

Beispiele

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());
    }
}

Ergebnis

2005
2005
0
0

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen