Dominando ConcurrentMap de Java: Mapas Thread-Safe Explicados

Interfaz ConcurrentMap de Java

Aprende cómo ConcurrentMap de Java ofrece operaciones de mapa thread-safe, sus métodos principales y un ejemplo práctico usando ConcurrentHashMap.

La interfaz ConcurrentMap extiende java.util.Map y proporciona una implementación de mapa altamente concurrente y thread-safe. Garantiza que múltiples hilos pueden realizar operaciones de lectura, escritura y actualización simultáneamente sin corromper el estado interno del mapa.

Como ConcurrentMap es una interfaz, no puedes instanciarla directamente. La implementación más común es java.util.concurrent.ConcurrentHashMap, que ofrece lecturas sin bloqueos y bloqueo de grano fino para actualizaciones.

Clases que Implementan ConcurrentMap

Aunque ConcurrentMap no puede instanciarse directamente, puedes crear un mapa concreto usando una de sus implementaciones. El estándar de facto es ConcurrentHashMap, pero existen alternativas como ConcurrentSkipListMap para requisitos de mapa ordenado.

Usando ConcurrentMap

Primero, importa la interfaz:

import java.util.concurrent.ConcurrentMap;

Luego crea una instancia de ConcurrentHashMap:

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

En este ejemplo, numeros es un mapa thread-safe donde cada clave String se empareja con un valor Integer.

Conceptos clave:

• Clave – identificador único que mapea a un valor.
• Valor – dato asociado con una clave.

Métodos Clave de ConcurrentMap

Además de todas las operaciones estándar de Map, ConcurrentMap introduce varios métodos atómicos, sin bloqueos:

• putIfAbsent(K key, V value) – Añade el par clave/valor solo si la clave no está ya presente.
• compute(K key, BiFunction) – Actualiza atómicamente el valor para la clave especificada basado en su valor actual.
• computeIfAbsent(K key, Function) – Genera un valor para una clave faltante usando una función suministrada.
• computeIfPresent(K key, BiFunction) – Actualiza el valor de una clave existente atómicamente.
• forEach(BiConsumer) – Realiza la acción dada para cada entrada.
• merge(K key, V value, BiFunction) – Combina el nuevo valor con el existente usando la función proporcionada.

Para una referencia en profundidad, consulta la documentación oficial de Java.

Usando ConcurrentHashMap con ConcurrentMap

import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentHashMap;
public class Main {
    public static void main(String[] args) {
        // Crear un mapa thread-safe
        ConcurrentMap<String, Integer> numeros = new ConcurrentHashMap<>();
        // Insertar elementos
        numeros.put("Dos", 2);
        numeros.put("Uno", 1);
        numeros.put("Tres", 3);
        System.out.println("ConcurrentMap: " + numeros);
        // Recuperar un valor
        int valor = numeros.get("Uno");
        System.out.println("Valor Accedido: " + valor);
        // Eliminar un par clave/valor
        int eliminado = numeros.remove("Dos");
        System.out.println("Valor Eliminado: " + eliminado);
    }
}

Salida

ConcurrentMap: {Uno=1, Dos=2, Tres=3} Valor Accedido: 1 Valor Eliminado: 2

Para uso más avanzado, consulta la documentación de ConcurrentHashMap.