Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

ConcurrentHashMap: inicialização atómica de contadores e percurso de entradas

Use `computeIfAbsent` para inicializar atomicamente um `LongAdder` para uma chave ausente e `forEach` para ler as contagens sem depender da ordem do percurso.

Versão: Java SE 21

Sintaxe

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)

Em Java SE 21, computeIfAbsent(key, factory) de java.util.concurrent.ConcurrentHashMap devolve atomicamente o valor existente sem chamar a função. Se a chave estiver ausente, chama a função uma vez nessa invocação, guarda o resultado se for diferente de null e devolve-o. A implementação predefinida de Map.computeIfAbsent não garante sincronização nem atomicidade. Uma referência do tipo Map para um objeto ConcurrentHashMap continua a chamar o método redefinido pela classe.

O mapa não admite chaves nem valores null. Uma chave ou função null provoca NullPointerException; se o resultado da função for null, o método devolve-o sem criar uma entrada. Uma RuntimeException ou um Error lançado pela função propaga-se sem criar uma entrada. A função deve ser breve e não deve modificar o mesmo mapa: outras atualizações podem ter de esperar e uma atualização recursiva detetada que, de outro modo, não terminaria provoca IllegalStateException.

Em counts.computeIfAbsent(word, k -> new LongAdder()).increment(), o contador de java.util.concurrent.atomic começa a zero. increment() é seguro entre threads, mas ocorre depois da operação sobre o mapa e não faz parte da mesma operação atómica. Se outra thread remover ou substituir a entrada, o incremento pode afetar um contador que já não está no mapa. sum() dá o valor exato quando não há atualizações simultâneas do contador, mas não é um instantâneo atómico.

forEach(action) passa a chave e o valor à ação sequencialmente, sem limiar. forEach(threshold, action) pode recorrer a ForkJoinPool.commonPool() consoante o tamanho estimado do mapa: Long.MAX_VALUE desativa a execução paralela e 1 favorece o paralelismo máximo. Uma ação executada em paralelo tem de aceder ao estado partilhado em segurança. forEach(threshold, transformer, action) passa à ação apenas os resultados da transformação diferentes de null. Nenhuma sobrecarga garante uma ordem de percurso ou um instantâneo atómico de todo o mapa durante as atualizações.

Exemplos

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

Depois das duas chamadas a `join()`, os contadores já não mudam. `Long.MAX_VALUE` mantém sequenciais as escritas no `TreeMap`, que ordena a saída por chave.

Lições relacionadas

  • Java · Lição 24 · Avançado · Versão: 2

Fontes