Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

LongAdder — conteggio e somma concorrenti

LongAdder accumula una somma di tipo long aggiornata da più thread. È adatto alle statistiche, ma sum() non fornisce un’istantanea atomica e, per azzerarlo, occorre controllare gli aggiornamenti concorrenti.

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

Sintassi

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 parte da zero e distribuisce gli aggiornamenti tra variabili interne per ridurre la contesa tra thread. In caso di contesa elevata può offrire una capacità di elaborazione maggiore rispetto ad AtomicLong, a scapito della memoria. Usalo per le statistiche, non per controllare con precisione la sincronizzazione.

LongAdder.increment() aggiunge uno e LongAdder.add(long) aggiunge il valore fornito; entrambi i metodi restituiscono void. LongAdder.sum() restituisce un long, ma non fornisce un’istantanea atomica: può non includere gli aggiornamenti che avvengono durante la lettura. In assenza di aggiornamenti concorrenti, il risultato è esatto.

LongAdder.reset() azzera lo stato e restituisce void; usa questo metodo solo quando nessun thread aggiorna il contatore. LongAdder.sumThenReset() restituisce la somma e azzera lo stato. Non considerarlo un limite atomico tra periodi di misurazione: con aggiornamenti concorrenti, il risultato potrebbe non essere il valore finale precedente all’azzeramento.

Nell’esempio, entrambe le chiamate a join() precedono le letture e l’azzeramento. In questo modo, l’output previsto è deterministico. La documentazione fa riferimento a Java SE 21; l’ambiente di esecuzione del repository non attesta quello di produzione.

Esempi

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

Risultato

2005
2005
0
0

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti