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