Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

ConcurrentHashMap: inizializzare contatori in modo atomico e visitare le voci

Usa `computeIfAbsent` per inizializzare atomicamente un `LongAdder` per una chiave assente e `forEach` per leggere i conteggi senza dipendere dall’ordine di visita.

Versione: Java SE 21

Sintassi

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)

In Java SE 21, computeIfAbsent(key, factory) di java.util.concurrent.ConcurrentHashMap restituisce atomicamente il valore esistente senza chiamare la funzione. Se la chiave è assente, chiama la funzione una volta per quella invocazione, memorizza il risultato se non è null e lo restituisce. L’implementazione predefinita di Map.computeIfAbsent non garantisce né sincronizzazione né atomicità. Anche con un riferimento di tipo Map a una ConcurrentHashMap viene eseguito il metodo ridefinito dalla classe.

La mappa non ammette chiavi o valori null. Una chiave o una funzione null causa una NullPointerException; se il risultato è null, viene restituito senza creare una voce. Una RuntimeException o un Error generato dalla funzione si propaga senza creare una voce. La funzione deve essere breve e non deve modificare la stessa mappa: altre operazioni di aggiornamento possono dover attendere, e un aggiornamento ricorsivo rilevato che altrimenti non terminerebbe causa una IllegalStateException.

In counts.computeIfAbsent(word, k -> new LongAdder()).increment(), il contatore di java.util.concurrent.atomic parte da zero. increment() è sicuro tra thread, ma avviene dopo l’operazione sulla mappa e non fa parte della stessa operazione atomica. Se un altro thread rimuove o sostituisce la voce, l’incremento può riguardare un contatore che non è più nella mappa. sum() dà un risultato esatto in assenza di aggiornamenti simultanei del contatore, ma non è un’istantanea atomica.

forEach(action) passa chiave e valore all’azione in sequenza, senza soglia. forEach(threshold, action) può usare ForkJoinPool.commonPool() in base alla dimensione stimata della mappa: Long.MAX_VALUE disattiva l’esecuzione parallela, mentre 1 favorisce il massimo parallelismo. Un’azione parallela deve accedere allo stato condiviso in modo sicuro. forEach(threshold, transformer, action) passa all’azione solo risultati della trasformazione diversi da null. Nessuna variante garantisce un ordine di visita o un’istantanea atomica dell’intera mappa durante gli aggiornamenti.

Esempi

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

Risultato

apple=2
pear=2
plum=1

Dopo entrambe le chiamate a `join()`, i contatori non cambiano più. `Long.MAX_VALUE` mantiene sequenziali le scritture nella `TreeMap`, che ordina l’output per chiave.

Lezioni correlate

  • Java · Lezione 24 · Avanzato · Versione: 2

Fonti