Dominando ConcurrentMap do Java: Mapas Thread-Safe Explicados

Interface ConcurrentMap do Java

Aprenda como o ConcurrentMap do Java fornece operações de mapa thread-safe, seus métodos principais e um exemplo prático usando ConcurrentHashMap.

A interface ConcurrentMap estende java.util.Map e fornece uma implementação de mapa altamente concorrente e thread-safe. Ela garante que múltiplas threads possam realizar operações de leitura, escrita e atualização simultaneamente sem corromper o estado interno do mapa.

Como ConcurrentMap é uma interface, você não pode instanciá-la diretamente. A implementação mais comum é java.util.concurrent.ConcurrentHashMap, que oferece leituras sem bloqueio e bloqueio de granulação fina para atualizações.

Classes que Implementam ConcurrentMap

Embora o ConcurrentMap em si não possa ser instanciado, você pode criar um mapa concreto usando uma de suas implementações. O padrão de fato é ConcurrentHashMap, mas alternativas como ConcurrentSkipListMap existem para requisitos de mapa ordenado.

Usando ConcurrentMap

Primeiro, importe a interface:

import java.util.concurrent.ConcurrentMap;

Então crie uma instância de ConcurrentHashMap:

ConcurrentMap<String, Integer> numeros = new ConcurrentHashMap<>();

Neste exemplo, numeros é um mapa thread-safe onde cada chave String é pareada com um valor Integer.

Conceitos-chave:

• Chave – um identificador único que mapeia para um valor.
• Valor – os dados associados a uma chave.

Métodos Principais do ConcurrentMap

Além de todas as operações padrão de Map, ConcurrentMap introduz vários métodos atômicos e sem bloqueio:

• putIfAbsent(K chave, V valor) – Adiciona o par chave/valor apenas se a chave não estiver já presente.
• compute(K chave, BiFunction) – Atualiza atomicamente o valor para a chave especificada baseada em seu valor atual.
• computeIfAbsent(K chave, Function) – Gera um valor para uma chave faltando usando uma função fornecida.
• computeIfPresent(K chave, BiFunction) – Atualiza o valor de uma chave existente atomicamente.
• forEach(BiConsumer) – Realiza a ação dada para cada entrada.
• merge(K chave, V valor, BiFunction) – Combina o novo valor com o existente usando a função fornecida.

Para uma referência aprofundada, veja a documentação oficial do Java.

Usando ConcurrentHashMap com ConcurrentMap

import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentHashMap;
public class Main {
    public static void main(String[] args) {
        // Criar um mapa thread-safe
        ConcurrentMap<String, Integer> numeros = new ConcurrentHashMap<>();
        // Inserir elementos
        numeros.put("Dois", 2);
        numeros.put("Um", 1);
        numeros.put("Três", 3);
        System.out.println("ConcurrentMap: " + numeros);
        // Recuperar um valor
        int valor = numeros.get("Um");
        System.out.println("Valor Acessado: " + valor);
        // Remover um par chave/valor
        int removido = numeros.remove("Dois");
        System.out.println("Valor Removido: " + removido);
    }
}

Saída

ConcurrentMap: {Um=1, Dois=2, Três=3} Valor Acessado: 1 Valor Removido: 2

Para uso mais avançado, consulte a documentação do ConcurrentHashMap.