ConcurrentHashMap en Java

Requisitos previos: ConcurrentMap

La clase ConcurrentHashMap se introduce en JDK 1.5 y pertenece al paquete java.util.concurrent , que implementa ConcurrentMap y también la interfaz Serializable. ConcurrentHashMap es una mejora de HashMap, ya que sabemos que al tratar con subprocesos en nuestra aplicación, HashMap no es una buena opción porque, en cuanto al rendimiento, HashMap no está a la altura.

Puntos clave de ConcurrentHashMap:  

• La estructura de datos subrayada para ConcurrentHashMap es Hashtable .
• La clase ConcurrentHashMap es segura para subprocesos, es decir, múltiples subprocesos pueden operar en un solo objeto sin ninguna complicación.
• En un momento, se puede aplicar cualquier cantidad de subprocesos para una operación de lectura sin bloquear el objeto ConcurrentHashMap que no está en HashMap.
• En ConcurrentHashMap, el objeto se divide en varios segmentos según el nivel de concurrencia.
• El nivel de simultaneidad predeterminado de ConcurrentHashMap es 16.
• En ConcurrentHashMap, cualquier número de subprocesos puede realizar una operación de recuperación a la vez, pero para actualizar el objeto, el subproceso debe bloquear el segmento particular en el que el subproceso desea operar. Este tipo de mecanismo de bloqueo se conoce como bloqueo de segmento o bloqueo de balde . Por lo tanto, los subprocesos pueden realizar 16 operaciones de actualización a la vez.
• No es posible insertar objetos nulos en ConcurrentHashMap como clave o valor.

Declaración:

clase pública ConcurrentHashMap<K,​V> extiende AbstractMap<K,​V> implementa ConcurrentMap<K,​V>, Serializable 
 

Aquí, K es el tipo de objeto clave y V es el tipo de objeto de valor.

La jerarquía de ConcurrentHashMap

Implementa interfaces Serializable , ConcurrentMap<K,​ V> , Map<K,​ V> y extiende   la clase AbstractMap<K, ​V> .

Constructores de ConcurrentHashMap

• Nivel de concurrencia: es el número de subprocesos que actualizan simultáneamente el mapa. La implementación realiza un dimensionamiento interno para tratar de acomodar esta cantidad de subprocesos.
• Factor de carga: es un umbral, que se utiliza para controlar el cambio de tamaño.
• Capacidad Inicial: Alojamiento de un determinado número de elementos inicialmente previstos por la implantación. si la capacidad de este mapa es 10. Significa que puede almacenar 10 entradas.

1. ConcurrentHashMap() : crea un nuevo mapa vacío con una capacidad inicial predeterminada (16), un factor de carga (0,75) y un nivel de concurrencia (16).

ConcurrentHashMap<K, V> chm = new ConcurrentHashMap<>();

2. ConcurrentHashMap(int initialCapacity) : crea un nuevo mapa vacío con la capacidad inicial especificada y con un factor de carga predeterminado (0,75) y concurrencyLevel (16).

ConcurrentHashMap<K, V> chm = new ConcurrentHashMap<>(int initialCapacity);

3. ConcurrentHashMap(int initialCapacity, float loadFactor) : crea un nuevo mapa vacío con la capacidad inicial y el factor de carga especificados y con el nivel de concurrencia predeterminado (16).

ConcurrentHashMap<K, V> chm = new ConcurrentHashMap<>(int initialCapacity, float loadFactor);

4. ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) : crea un nuevo mapa vacío con la capacidad inicial, el factor de carga y el nivel de simultaneidad especificados.

ConcurrentHashMap<K, V> chm = new ConcurrentHashMap<>(int initialCapacity, float loadFactor, int concurrencyLevel);

5. ConcurrentHashMap(Map m) : crea un nuevo mapa con las mismas asignaciones que el mapa dado.

ConcurrentHashMap<K, V> chm = new ConcurrentHashMap<>(Mapa m);

Ejemplo:

// Java program to demonstrate working of ConcurrentHashMap
 
import java.util.concurrent.*;
 
class ConcurrentHashMapDemo {
 
    public static void main(String[] args)
    {
        // create an instance of
        // ConcurrentHashMap
        ConcurrentHashMap<Integer, String> m
            = new ConcurrentHashMap<>();
 
        // Insert mappings using
        // put method
        m.put(100, "Hello");
        m.put(101, "Geeks");
        m.put(102, "Geeks");
 
        // Here we cant add Hello because 101 key
        // is already present in ConcurrentHashMap object
        m.putIfAbsent(101, "Hello");
 
        // We can remove entry because 101 key
        // is associated with For value
        m.remove(101, "Geeks");
 
        // Now we can add Hello
        m.putIfAbsent(103, "Hello");
 
        // We cant replace Hello with For
        m.replace(101, "Hello", "For");
        System.out.println(m);
    }
}

{100=Hello, 102=Geeks, 103=Hello}

Operaciones básicas en ConcurrentHashMap

1. Agregar elementos

Para insertar asignaciones en un ConcurrentHashMap, podemos usar los métodos put() o putAll() . El siguiente código de ejemplo explica estos dos métodos.

// Java program to demonstrate adding
// elements to the ConcurrentHashMap
 
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
 
public class AddingElementsToConcuurentHashMap {
 
    public static void main(String[] args)
    {
        // Creating ConcurrentHashMap
        ConcurrentHashMap<String, String> my_cmmap
            = new ConcurrentHashMap<String, String>();
 
        // Adding elements to the map
        // using put() method
        my_cmmap.put("1", "1");
        my_cmmap.put("2", "1");
        my_cmmap.put("3", "1");
        my_cmmap.put("4", "1");
        my_cmmap.put("5", "1");
        my_cmmap.put("6", "1");
 
        // Printing the map
        System.out.println("Mappings of my_cmmap : "
                           + my_cmmap);
 
        // create another concurrentHashMap
        ConcurrentHashMap<String, String> new_chm
            = new ConcurrentHashMap<>();
 
        // copy mappings from my_cmmap to new_chm
        new_chm.putAll(my_cmmap);
 
        // Displaying the new map
        System.out.println("New mappings are: " + new_chm);
    }
}

Mappings of my_cmmap : {1=1, 2=1, 3=1, 4=1, 5=1, 6=1}
New mappings are: {1=1, 2=1, 3=1, 4=1, 5=1, 6=1}

2. Eliminación de elementos

Para eliminar una asignación, podemos usar el método remove (clave de objeto) de la clase ConcurrentHashmap. Si la clave no existe en el mapa, entonces esta función no hace nada. Para borrar todo el mapa, podemos usar el método clear() . 

// Java program to demonstrate removing
// elements from ConcurrentHashMap
 
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
 
public class RemoveElementsFromConcurrentHashMap {
 
    public static void main(String[] args)
    {
        // Creating ConcurrentHashMap
        Map<String, String> my_cmmap
            = new ConcurrentHashMap<String, String>();
 
        // Adding elements to the map
        // using put() method
        my_cmmap.put("1", "1");
        my_cmmap.put("2", "1");
        my_cmmap.put("3", "1");
        my_cmmap.put("4", "1");
        my_cmmap.put("5", "1");
        my_cmmap.put("6", "1");
 
        // Printing the map
        System.out.println("Map: " + my_cmmap);
        System.out.println();
 
        // Removing the mapping
        // with existing key 6
        // using remove() method
        String valueRemoved = my_cmmap.remove("6");
 
        // Printing the map after remove()
        System.out.println(
            "After removing mapping with key 6:");
        System.out.println("Map: " + my_cmmap);
        System.out.println("Value removed: "
                           + valueRemoved);
        System.out.println();
 
        // Removing the mapping
        // with non-existing key 10
        // using remove() method
        valueRemoved = my_cmmap.remove("10");
 
        // Printing the map after remove()
        System.out.println(
            "After removing mapping with key 10:");
        System.out.println("Map: " + my_cmmap);
        System.out.println("Value removed: "
                           + valueRemoved);
        System.out.println();
 
        // Now clear the map using clear()
        my_cmmap.clear();
 
        // Print the clea Map
        System.out.println("Map after use of clear(): "
                           + my_cmmap);
    }
}

Map: {1=1, 2=1, 3=1, 4=1, 5=1, 6=1}

After removing mapping with key 6:
Map: {1=1, 2=1, 3=1, 4=1, 5=1}
Value removed: 1

After removing mapping with key 10:
Map: {1=1, 2=1, 3=1, 4=1, 5=1}
Value removed: null

Map after use of clear(): {}

 3. Accediendo a los Elementos

Podemos acceder a los elementos de un ConcurrentHashMap usando el método get() , el ejemplo de esto se da a continuación. 

// Java Program Demonstrate accessing
// elements of ConcurrentHashMap
 
import java.util.concurrent.*;
 
class AccessingElementsOfConcurrentHashMap {
 
    public static void main(String[] args)
    {
 
        // create an instance of ConcurrentHashMap
        ConcurrentHashMap<Integer, String> chm
            = new ConcurrentHashMap<Integer, String>();
 
        // insert mappings using put method
        chm.put(100, "Geeks");
        chm.put(101, "for");
        chm.put(102, "Geeks");
        chm.put(103, "Contribute");
 
        // Displaying the HashMap
        System.out.println("The Mappings are: ");
        System.out.println(chm);
 
        // Display the value of 100
        System.out.println("The Value associated to "
                           + "100 is : " + chm.get(100));
 
        // Getting the value of 103
        System.out.println("The Value associated to "
                           + "103 is : " + chm.get(103));
    }
}

The Mappings are: 
{100=Geeks, 101=for, 102=Geeks, 103=Contribute}
The Value associated to 100 is : Geeks
The Value associated to 103 is : Contribute

4. Atravesando

Podemos usar la interfaz Iterator para atravesar cualquier estructura del Framework de colección. Dado que los iteradores trabajan con un tipo de datos, usamos Entry< ? , ? > para resolver los dos tipos separados en un formato compatible. Luego, usando el método next(), imprimimos los elementos del ConcurrentHashMap. 

// Java Program for traversing a
// ConcurrentHashMap
import java.util.*;
import java.util.concurrent.*;
 
public class TraversingConcurrentHashMap {
 
    public static void main(String[] args)
    {
 
        // create an instance of ConcurrentHashMap
        ConcurrentHashMap<Integer, String> chmap
            = new ConcurrentHashMap<Integer, String>();
 
        // Add elements using put()
        chmap.put(8, "Third");
        chmap.put(6, "Second");
        chmap.put(3, "First");
        chmap.put(11, "Fourth");
 
        // Create an Iterator over the
        // ConcurrentHashMap
        Iterator<ConcurrentHashMap.Entry<Integer, String> >
            itr = chmap.entrySet().iterator();
 
        // The hasNext() method is used to check if there is
        // a next element The next() method is used to
        // retrieve the next element
        while (itr.hasNext()) {
            ConcurrentHashMap.Entry<Integer, String> entry
                = itr.next();
            System.out.println("Key = " + entry.getKey()
                               + ", Value = "
                               + entry.getValue());
        }
    }
}

Key = 3, Value = First
Key = 6, Value = Second
Key = 8, Value = Third
Key = 11, Value = Fourth

Métodos de ConcurrentHashMap

• K – El tipo de claves en el mapa.
• V – El tipo de valores mapeados en el mapa.

Métodos declarados en la clase java.util.AbstractMap

Métodos declarados en la interfaz java.util.concurrent.ConcurrentMap

Debe leer: Diferencia entre HashMap y ConcurrentHashMap

ConcurrentHashMap frente a Hashtable

Tabla de picadillo 

• Hashtable es una implementación de la estructura de datos del mapa
• Esta es una clase heredada en la que todos los métodos se sincronizan en instancias de Hashtable usando la palabra clave sincronizada.
• Seguro para subprocesos ya que su método está sincronizado

ConcurrentHashMapConcurrentHashMap 

• ConcurrentHashMap implementa la estructura de datos del mapa y también proporciona seguridad de subprocesos como Hashtable.
• Funciona dividiendo la array completa de tablas hash en segmentos o porciones y permitiendo el acceso paralelo a esos segmentos.
• El bloqueo tiene una granularidad mucho más fina a nivel de depósito de hashmap.
• Use ConcurrentHashMap cuando necesite una concurrencia muy alta en su aplicación.
• Es seguro para subprocesos sin sincronizar todo el mapa.
• Las lecturas pueden ocurrir muy rápido mientras que la escritura se realiza con un bloqueo a nivel de segmento o nivel de depósito.
• No hay bloqueo a nivel de objeto.
• ConcurrentHashMap no lanza una ConcurrentModificationException si un subproceso intenta modificarlo mientras otro itera sobre él.
• ConcurrentHashMap no permite valores NULL, por lo que la clave no puede ser nula en ConcurrentHashMap
• ConcurrentHashMap no lanza una ConcurrentModificationException si un subproceso intenta modificarlo, mientras que otro está iterando sobre él.

Conclusión:

Si se desea una implementación altamente simultánea segura para subprocesos, se recomienda usar ConcurrentHashMap en lugar de Hashtable .

Referencia: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ConcurrentHashMap.html