Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

LongAdder — conteo y suma concurrentes

LongAdder acumula una suma de tipo long actualizada por varios hilos. Es adecuado para estadísticas, pero sum() no ofrece una instantánea atómica y, para reiniciarlo, hay que controlar las actualizaciones concurrentes.

Versión: Java SE 21; repository runtime, production runtime not attested

Sintaxis

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 empieza en cero y distribuye las actualizaciones entre variables internas para reducir la contención entre hilos. Con mucha contención puede ofrecer un mayor rendimiento que AtomicLong, a costa de consumir más memoria. Úsalo para estadísticas, no para controlar con precisión la sincronización.

LongAdder.increment() suma uno y LongAdder.add(long) suma el valor indicado; ambos métodos devuelven void. LongAdder.sum() devuelve un long, pero no ofrece una instantánea atómica: puede no incluir las actualizaciones que se produzcan durante la lectura. Si no hay actualizaciones concurrentes, el resultado es exacto.

LongAdder.reset() pone el estado a cero y devuelve void; úsalo solo cuando ningún hilo esté actualizando el contador. LongAdder.sumThenReset() devuelve la suma y pone el estado a cero. No lo consideres un límite atómico entre periodos de medición: si hay actualizaciones concurrentes, el resultado no tiene por qué ser el valor final anterior al reinicio.

En el ejemplo, las dos llamadas a join() se realizan antes de leer y reiniciar. Así, la salida esperada es determinista. El alcance de la documentación es Java SE 21; el entorno de ejecución del repositorio no confirma el entorno de producción.

Ejemplos

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

Resultado

2005
2005
0
0

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes