Concurrencia Java - Interfaz ConcurrentMap

Una interfaz java.util.concurrent.ConcurrentMap es una subinterfaz de la interfaz Map, admite operaciones atómicas en la variable de mapa subyacente. Tiene métodos get y set que funcionan como lectura y escritura en variables volátiles. Es decir, un conjunto tiene una relación de suceder antes con cualquier obtención posterior de la misma variable. Esta interfaz garantiza la seguridad de los hilos y las garantías de atomicidad.

Métodos ConcurrentMap

No Señor.	Método y descripción
1	default V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) Intenta calcular un mapeo para la clave especificada y su valor mapeado actual (o nulo si no hay mapeo actual).
2	default V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction) Si la clave especificada aún no está asociada con un valor (o está asignada a nulo), intenta calcular su valor utilizando la función de asignación dada y la ingresa en este mapa a menos que sea nula.
3	default V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) Si el valor de la clave especificada está presente y no es nulo, intenta calcular una nueva asignación dada la clave y su valor asignado actual.
4	default void forEach(BiConsumer<? super K,? super V> action) Realiza la acción dada para cada entrada en este mapa hasta que se hayan procesado todas las entradas o la acción arroje una excepción.
5	default V getOrDefault(Object key, V defaultValue) Devuelve el valor al que se asigna la clave especificada, o defaultValue si este mapa no contiene ninguna asignación para la clave.
6	default V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction) Si la clave especificada aún no está asociada con un valor o está asociada con nulo, la asocia con el valor no nulo dado.
7	V putIfAbsent(K key, V value) Si la clave especificada aún no está asociada con un valor, asóciela con el valor dado.
8	boolean remove(Object key, Object value) Elimina la entrada de una clave solo si está asignada actualmente a un valor determinado.
9	V replace(K key, V value) Reemplaza la entrada de una clave solo si actualmente está asignada a algún valor.
10	boolean replace(K key, V oldValue, V newValue) Reemplaza la entrada de una clave solo si actualmente está asignada a un valor dado.
11	default void replaceAll(BiFunction<? super K,? super V,? extends V> function) Reemplaza el valor de cada entrada con el resultado de invocar la función dada en esa entrada hasta que todas las entradas hayan sido procesadas o la función arroje una excepción.

Ejemplo

El siguiente programa TestThread muestra el uso de ConcurrentMap vs HashMap.

import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class TestThread {

   public static void main(final String[] arguments) {
      Map<String,String> map = new ConcurrentHashMap<String, String>();

      map.put("1", "One");
      map.put("2", "Two");
      map.put("3", "Three");
      map.put("5", "Five");
      map.put("6", "Six");

      System.out.println("Initial ConcurrentHashMap: " + map);
      Iterator<String> iterator = map.keySet().iterator();

      try { 
         
         while(iterator.hasNext()) {
            String key = iterator.next();
            
            if(key.equals("3")) {
               map.put("4", "Four");
            }
         }
      } catch(ConcurrentModificationException cme) {
         cme.printStackTrace();
      }
      System.out.println("ConcurrentHashMap after modification: " + map);

      map = new HashMap<String, String>();

      map.put("1", "One");
      map.put("2", "Two");
      map.put("3", "Three");
      map.put("5", "Five");
      map.put("6", "Six");

      System.out.println("Initial HashMap: " + map);
      iterator = map.keySet().iterator();

      try {
         
         while(iterator.hasNext()) {
            String key = iterator.next();
            
            if(key.equals("3")) {
               map.put("4", "Four");
            }
         }
         System.out.println("HashMap after modification: " + map);
      } catch(ConcurrentModificationException cme) {
         cme.printStackTrace();
      }
   }  
}

Esto producirá el siguiente resultado.

Salida

Initial ConcurrentHashMap: {1 = One, 2 = Two, 3 = Three, 5 = Five, 6 = Six}
ConcurrentHashMap after modification: {1 = One, 2 = Two, 3 = Three, 4 = Four, 5 = Five, 6 = Six}
Initial HashMap: {1 = One, 2 = Two, 3 = Three, 5 = Five, 6 = Six}
java.util.ConcurrentModificationException
	at java.util.HashMap$HashIterator.nextNode(Unknown Source)
	at java.util.HashMap$KeyIterator.next(Unknown Source)
	at TestThread.main(TestThread.java:48)