Diferencia entre ConcurrentHashMap y SynchronizedHashMap

Tanto ConcurrentHashMap como SynchronizedHashMap son clases de colección que son seguras para subprocesos y se pueden usar en aplicaciones Java simultáneas y de subprocesos múltiples. Pero son pocas las diferencias que existen entre ellos. En este artículo, hemos tratado de cubrir todas estas diferencias entre ellos.

1. ConcurrentHashMap : ConcurrentHashMap es una clase que implementa la interfaz ConcurrentMap. Utiliza Hashtable , estructura de datos subrayada. Como sabemos, al tratar con subprocesos en nuestra aplicación, HashMap no es una buena opción debido al problema de rendimiento. Para resolver este problema, usamos ConcurrentHashMap en nuestra aplicación. ConcurrentHashMap es seguro para subprocesos, por lo tanto, múltiples subprocesos pueden operar en un solo objeto sin ningún problema. En ConcurrentHashMap, el objeto se divide en varios segmentos según el nivel de concurrencia. Por defecto, permite que 16 hilos lean y escriban desde el Mapasin ninguna sincronización. 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 desea operar. Este tipo de mecanismo de bloqueo se conoce como bloqueo de segmento o bloqueo de balde . Por lo tanto, en un momento16 las operaciones de actualización pueden ser realizadas por subprocesos.

Demostración de ConcurrentHashMap:

// Java Program to demonstrate the
// working of 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(10, "Geeks");
        chmap.put(20, "for");
        chmap.put(30, "Geeks");
        chmap.put(40, "Welcome");
        chmap.put(50, "you");
 
        // 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 and 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 = 50, Value = you
Key = 20, Value = for
Key = 40, Value = Welcome
Key = 10, Value = Geeks
Key = 30, Value = Geeks

2. HashMap sincronizado: Java HashMap es una clase de colección no sincronizada. Si necesitamos realizar operaciones seguras para subprocesos en él, debemos sincronizarlo explícitamente. El método sincronizadoMap() de la clase java.util.Collections se utiliza para sincronizarlo. Devuelve un mapa sincronizado (seguro para subprocesos) respaldado por el mapa especificado. 

Demostración de HashMap sincronizado: 

// Java program to demonstrate the
// working of Synchronized HashMap
 
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
 
public class SynchronizedHashMap {
    public static void main(String args[])
    {
 
        // Creating a HashMap
        HashMap<Integer, String> hmap
            = new HashMap<Integer, String>();
 
        // Adding the elements using put method
        hmap.put(10, "Geeks");
        hmap.put(20, "for");
        hmap.put(30, "Geeks");
        hmap.put(25, "Welcome");
        hmap.put(40, "you");
 
        // Creating a synchronized map
        Map map = Collections.synchronizedMap(hmap);
        Set set = map.entrySet();
 
        // Synchronize on HashMap, not on set
        synchronized (map)
        {
            Iterator i = set.iterator();
            // Printing the elements
            while (i.hasNext()) {
                Map.Entry me = (Map.Entry)i.next();
                System.out.print(me.getKey() + ": ");
                System.out.println(me.getValue());
            }
        }
    }
}

20: for
40: you
25: Welcome
10: Geeks
30: Geeks

Diferencia entre ConcurrentHashMap y Synchronized HashMap: