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

CKTIS / Java

ConcurrentHashMap: inicialización atómica de contadores y recorrido de entradas

Usa `computeIfAbsent` para inicializar de forma atómica un `LongAdder` para una clave ausente y `forEach` para leer los recuentos sin depender del orden de recorrido.

Versión: Java SE 21

Sintaxis

V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
void forEach(BiConsumer<? super K, ? super V> action)
void forEach(long parallelismThreshold, BiConsumer<? super K, ? super V> action)
<U> void forEach(long parallelismThreshold, BiFunction<? super K, ? super V, ? extends U> transformer, Consumer<? super U> action)

En Java SE 21, computeIfAbsent(key, factory) de java.util.concurrent.ConcurrentHashMap devuelve de forma atómica el valor existente sin llamar a la función. Si la clave no está presente, llama a la función una vez en esa invocación, guarda el resultado si no es null y lo devuelve. La implementación predeterminada de Map.computeIfAbsent no garantiza ni sincronización ni atomicidad. Una referencia de tipo Map a un objeto ConcurrentHashMap sigue invocando la implementación de la clase.

El mapa no admite claves ni valores null. Una clave o función null provoca NullPointerException; si la función devuelve null, el método lo devuelve sin crear una entrada. Si la función lanza RuntimeException o Error, se propaga sin crear una entrada. La función debe ser breve y no debe modificar ese mismo mapa: otras actualizaciones pueden tener que esperar y, si se detecta una actualización recursiva que no podría completarse, se lanza IllegalStateException.

En counts.computeIfAbsent(word, k -> new LongAdder()).increment(), el contador de java.util.concurrent.atomic comienza en cero. La llamada a increment() es segura entre hilos, pero ocurre después de la operación sobre el mapa y no forma parte de la misma operación atómica. Si otro hilo elimina o sustituye la entrada, el incremento puede aplicarse a un contador que ya no está en el mapa. sum() es exacto sin actualizaciones simultáneas del contador, pero no es una instantánea atómica.

forEach(action) pasa la clave y el valor a la acción de forma secuencial, sin umbral. forEach(threshold, action) puede usar ForkJoinPool.commonPool() según el tamaño estimado del mapa: Long.MAX_VALUE desactiva la ejecución paralela y 1 favorece el máximo paralelismo. Una acción paralela debe acceder al estado compartido de forma segura. forEach(threshold, transformer, action) solo pasa a la acción resultados de transformación distintos de null. Ninguna sobrecarga garantiza un orden de recorrido ni una instantánea atómica de todo el mapa durante las actualizaciones.

Ejemplos

import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.LongAdder;

public class WordCounts {
    private static void count(ConcurrentHashMap<String, LongAdder> counts,
                              String... words) {
        for (String word : words) {
            counts.computeIfAbsent(word, k -> new LongAdder()).increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        var counts = new ConcurrentHashMap<String, LongAdder>();
        var first = new Thread(() -> count(counts, "pear", "apple", "pear"));
        var second = new Thread(() -> count(counts, "apple", "plum"));
        first.start();
        second.start();
        first.join();
        second.join();

        var sorted = new TreeMap<String, Long>();
        counts.forEach(Long.MAX_VALUE, (word, counter) -> sorted.put(word, counter.sum()));
        sorted.forEach((word, total) -> System.out.println(word + "=" + total));
    }
}

Resultado

apple=2
pear=2
plum=1

Tras ambas llamadas a `join()`, los contadores ya no cambian. `Long.MAX_VALUE` mantiene secuenciales las escrituras en el `TreeMap`, que ordena la salida por clave.

Lecciones relacionadas

  • Java · Lección 24 · Avanzado · Versión: 2

Fuentes