CKTIS / Java
ConcurrentHashMap: get, put e merge atómico
Usa `get` para ler, `put` para escrever sem condições e `merge` para atualizar uma única chave de forma atómica, por exemplo num contador partilhado entre threads.
Versão: Java SE 21
Sintaxe
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiFunction;
// Instance methods of ConcurrentHashMap<K, V>
public V get(Object key)
public V put(K key, V value)
public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)Em Java SE 21, ConcurrentHashMap.get (get(Object key)) lê um valor sem alterar o mapa e devolve null se a chave não existir. ConcurrentHashMap.put insere ou substitui um valor e devolve o valor anterior, ou null se não havia entrada.
Se a chave não existir, ConcurrentHashMap.merge insere o valor fornecido sem chamar a função. Se a chave existir, chama a função com o valor existente como primeiro argumento e o valor fornecido como segundo. Guarda e devolve o resultado ou, se a função devolver null, remove a entrada e devolve null.
O mapa não aceita chaves nem valores null. Uma chave null em qualquer destes métodos, um valor null passado a put ou merge ou uma função null passada a merge provoca uma NullPointerException. Se a função lançar uma RuntimeException ou um Error, merge propaga-a sem alterar a entrada. Mantém a função curta: algumas atualizações poderão ter de esperar que termine. A função não pode alterar este mapa durante o cálculo. Se merge detetar uma tentativa de atualização recursiva deste mapa que, de outro modo, nunca terminaria, lança uma IllegalStateException.
Uma chamada a merge lê e atualiza a entrada de uma chave de forma atómica. Chamadas separadas a get e put podem perder um incremento se duas threads lerem o mesmo valor e escreverem o mesmo resultado. Esta garantia pertence a ConcurrentHashMap, não à implementação predefinida de Map.merge, e não fornece uma transação que abranja várias chaves.
Exemplos
import java.util.concurrent.ConcurrentHashMap;
public class Main {
public static void main(String[] args) throws InterruptedException {
var counts = new ConcurrentHashMap<String, Integer>();
String key = "hits";
System.out.println(counts.get(key));
System.out.println(counts.merge(key, 1, Integer::sum));
System.out.println(counts.put(key, 10));
Runnable increment = () -> {
for (int i = 0; i < 1_000; i++) {
counts.merge(key, 1, Integer::sum);
}
};
Thread first = new Thread(increment);
Thread second = new Thread(increment);
first.start();
second.start();
first.join();
second.join();
System.out.println(counts.get(key));
System.out.println(counts.merge(key, 1, (oldValue, addedValue) -> null));
System.out.println(counts.get(key));
}
}Resultado
null 1 1 2010 null null
A primeira leitura devolve `null`. O primeiro `merge` insere e devolve `1`, e `put` guarda `10` e devolve o `1` anterior. Cada thread soma 1000; `join()` espera que ambas terminem antes da leitura de `2010`. O último `merge` remove a entrada, pelo que tanto essa chamada como a leitura seguinte devolvem `null`.
Lições relacionadas
- Java · Lição 56 · Intermédio · Versão: 2