KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

LongAdder — gelijktijdig tellen en optellen

LongAdder verzamelt een som van het type long die door meerdere threads wordt bijgewerkt. Het is geschikt voor statistieken, maar sum() geeft geen atomair momentbeeld en voor resetten moet je gelijktijdige updates beheersen.

Versie: 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 begint bij nul en verdeelt updates over interne variabelen om threadconcurrentie te verminderen. Bij veel concurrentie kan het een hogere doorvoer bieden dan AtomicLong, ten koste van geheugen. Gebruik het voor statistieken, niet voor nauwkeurige synchronisatiebesturing.

LongAdder.increment() telt er één bij op en LongAdder.add(long) telt de opgegeven waarde erbij op; beide methoden retourneren void. LongAdder.sum() retourneert een long, maar geeft geen atomair momentbeeld: updates die tijdens het lezen plaatsvinden, kunnen ontbreken. Zonder gelijktijdige updates is het resultaat exact.

LongAdder.reset() wist de status en retourneert void; gebruik deze methode alleen wanneer geen enkele thread de teller bijwerkt. LongAdder.sumThenReset() retourneert de som en wist de status. Beschouw dit niet als een atomische grens tussen meetperioden: bij gelijktijdige updates hoeft het resultaat niet de uiteindelijke waarde vóór het wissen te zijn.

In het voorbeeld staan beide aanroepen van join() vóór het lezen en resetten. Daardoor is de verwachte uitvoer deterministisch. De documentatie heeft betrekking op Java SE 21; de runtime van de repository bevestigt niet welke runtime in productie wordt gebruikt.

Voorbeelden

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

Resultaat

2005
2005
0
0

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen