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

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

Fontes