Diferencia entre ConcurrentHashMap, HashTable y Synchronized Map en Java

Aquí discutiremos uno por uno individualmente y luego pasaremos a la diferencia después de tener una comprensión adecuada de los tres. Hablaremos primero de ConcurrentHashMap, seguido de HashTable, y finalmente de Synchronized Map. Comencemos con ConcurrentHashMap primero.

La estructura de datos subyacente para ConcurrentHashMap es HashTable . ConcurrentHashMap permite operaciones simultáneas de lectura y actualización segura para subprocesos. Para realizar la operación de lectura, el subproceso no requerirá ningún bloqueo, pero para realizar la operación de actualización, el subproceso requiere un bloqueo, pero es el bloqueo de solo una parte particular del Mapa (bloqueo de nivel de cubo). En lugar de una actualización concurrente de todo el mapa, se logra dividiendo internamente el mapa en una porción más pequeña que se define por el nivel de concurrencia. El nivel de concurrencia predeterminado es 16, es decir, ConcurrentHashMap permite operaciones simultáneas de lectura y 16 de escritura (actualización). El valor nulo no está permitido tanto para claves como para valores. Mientras un subproceso está iterando, el otro subproceso puede realizar una operación de actualización y ConcurrentHashMap nunca lanza ConcurrentModificationException.

Sintaxis:

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

El constructor anterior crea un ConcurrentHashMap vacío con 

• La capacidad inicial predeterminada es igual a 16
• La relación de llenado predeterminada es igual a 0,75
• Nivel de simultaneidad predeterminado 16 donde K es clave y V es el valor de ConcurrentHashMap

Ejemplo:

// Java program to illustrate ConcurrentHashMap
 
// Importing required packages
import java.io.*;
import java.util.*;
import java.util.concurrent.*;
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating ConcurrentHashMap class object
        // Declaring object of integer an string type
        ConcurrentHashMap<Integer, String> chm
            = new ConcurrentHashMap<>();
 
        // Adding entry to ConcurrentHashMap
        // Custom input entries
        chm.put(65, "A");
        chm.put(66, "B");
 
        // Print and display the ConcurrentHashMap
        System.out.println(chm);
 
        // Adding the entry if the given entry is not
        // present in the ConcurrentHashMap Custom input
        // entries
        chm.putIfAbsent(67, "C");
        chm.putIfAbsent(68, "D");
 
        // Printand display the ConcurrentHashMap
        System.out.println(chm);
 
        // Removing entry With Key and Value as 68 and D
        chm.remove(68, "D");
 
        // Print and display the ConcurrentHashMap
        System.out.println(chm);
 
        // Replacing  Value of an entry
        chm.replace(66, "B", "E");
 
        // Again, print and display the ConcurrentHashMap
        System.out.println(chm);
    }
}

{65=A, 66=B}
{65=A, 66=B, 67=C, 68=D}
{65=A, 66=B, 67=C}
{65=A, 66=E, 67=C}

Ahora deteniéndonos en el segundo concepto que es HashTable . La estructura de datos subyacente para HashTable es HashTable. El orden de inserción en HashTable no se conserva y se basa en el código hash de las claves. No se permiten claves duplicadas, pero se pueden duplicar valores. Se permiten objetos heterogéneos tanto para claves como para valores. El valor nulo no está permitido tanto para la clave como para el valor; de lo contrario, obtendremos RunTimeException diciendo NullPointerException. Implementa interfaces serializables y clonables pero no RandomAccess. Cada método dentro de él está sincronizado y, por lo tanto, los objetos HashTable son seguros para subprocesos. HashTable es la mejor opción si nuestra operación frecuente es la operación de búsqueda.

Sintaxis: 

Hashtable<K,V> ht = new Hashtable<>();

El constructor anterior crea un objeto de tabla hash vacío con una capacidad predeterminada inicial de 11 y una tasa de llenado predeterminada de 0,75. Donde K es clave y V es el valor de una tabla hash.

Ejemplo: 

// Java program to illustrate HashTable
 
// Importing required packages
import java.io.*;
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating Hashtable object
        Hashtable<Integer, String> ht = new Hashtable<>();
 
        // Adding entry to Hashtable
        // Custom input entries
        ht.put(65, "A");
        ht.put(66, "B");
        ht.put(67, "C");
        ht.put(68, "D");
 
        // Print and display the HashTable elements
        System.out.println(ht);
    }
}

{65=A, 68=D, 67=C, 66=B}

Por último, discutiendo el   Mapa Sincronizado antes de llegar a las diferencias concluyentes entre los tres. El métodosynchronedMap() se utiliza para devolver un mapa sincronizado (seguro para subprocesos) respaldado por el mapa especificado. Este método está presente en java.util.Collections.

Sintaxis: 

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> M)

// where M is the map to be synchronized K is key 
//   and V is value for the resultant synchronized map.    

Ejemplo:

// Java program to demonstrate synchronizedMap() method
 
// Importing required packages
import java.io.*;
import java.util.*;
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Try block to check for exceptions
        try {
 
            // Creating object of HashMap
            // Declaring object of integer and string type
            HashMap<Integer, String> map = new HashMap<>();
 
            // Adding entry to map object created above
            // Custom input entries
            map.put(65, "A");
            map.put(66, "B");
            map.put(67, "C");
            map.put(68, "D");
 
            // Print and display the map object
            System.out.println("Map is " + map);
 
            // Creating a synchronized map object
            // Declaring object of type integer and string
            Map<Integer, String> synmap
                = Collections.synchronizedMap(map);
 
            // Print and display the synchronized map
            // elements
            System.out.println("Synchronized map is : "
                               + synmap);
        }
 
        // Catch block to handle the exceptions
        catch (IllegalArgumentException e) {
 
            // Display the exception on the console
            System.out.println(e);
        }
    }
}

Map is {65=A, 66=B, 67=C, 68=D}
Synchronized map is : {65=A, 66=B, 67=C, 68=D}

Hasta ahora hemos discutido lo suficiente los conceptos junto con el trabajo interno a través de la implementación en los programas. Finalmente, concluyamos las diferencias entre ellos para obtener un control estricto y comprender la diferencia mínima entre ellos.