Diferencia entre HashMap y ConcurrentHashMap

HashMap es la Clase que está bajo la Colección Tradicional y ConcurrentHashMap es una Clase que está bajo las Colecciones Concurrentes, aparte de esto, hay varias diferencias entre ellos que son:

• HashMap es de naturaleza no sincronizada, es decir, HashMap no es seguro para subprocesos, mientras que ConcurrentHashMap es de naturaleza segura para subprocesos.
• El rendimiento de HashMap es relativamente alto porque no está sincronizado por naturaleza y cualquier cantidad de subprocesos puede funcionar simultáneamente. Pero el rendimiento de ConcurrentHashMap es bajo a veces porque a veces se requiere que los subprocesos esperen en ConcurrentHashMap.
• Mientras un subproceso está iterando el objeto HashMap, si otro subproceso intenta agregar/modificar el contenido del objeto, obtendremos una excepción en tiempo de ejecución que dice ConcurrentModificationException . Mientras que en ConcurrentHashMap no obtendremos ninguna excepción al realizar cualquier modificación en el momento de la iteración.

Usando HashMap

// Java program to illustrate // HashMap drawbacks import java.util.HashMap;    class HashMapDemo extends Thread {     static HashMap<Integer,String> l=new HashMap<Integer,String>();        public void run()     {                           try         {             Thread.sleep(1000);             // Child thread trying to add             // new element in the object             l.put(103,"D");         }         catch(InterruptedException e)         {             System.out.println("Child Thread going to add element");         }     }        public static void main(String[] args) throws InterruptedException     {         l.put(100,"A");         l.put(101,"B");         l.put(102,"C");         HashMapDemo t=new HashMapDemo();         t.start();                    for (Object o : l.entrySet())          {             Object s=o;             System.out.println(s);             Thread.sleep(1000);         }         System.out.println(l);     } }

Producción:

100=A
Exception in thread "main" java.util.ConcurrentModificationException

Usando ConcurrentHashMap

// Java program to illustrate
// HashMap drawbacks
import java.util.HashMap;
import java.util.concurrent.*;
  
class HashMapDemo extends Thread
{
    static ConcurrentHashMap<Integer,String> l = 
                       new ConcurrentHashMap<Integer,String>();
  
    public void run()
    {
      
        // Child add new element in the object
        l.put(103,"D");
          
        try
        {
            Thread.sleep(2000);
        }
        catch(InterruptedException e)
        {
            System.out.println("Child Thread going to add element");
        }
    }
      
    public static void main(String[] args) throws InterruptedException
    {
        l.put(100,"A");
        l.put(101,"B");
        l.put(102,"C");
        HashMapDemo t=new HashMapDemo();
        t.start();
          
        for (Object o : l.entrySet()) 
        {
            Object s=o;
            System.out.println(s);
            Thread.sleep(1000);
        }
        System.out.println(l);
    }
}

Producción:

100=A
101=B
102=C
103=D
{100=A, 101=B, 102=C, 103=D}

Usando HashMap

//Java Program to illustrate ConcurrentHashMap behaviour
import java.util.*;
class ConcurrentHashMapDemo
{
    public static void main(String[] args)
    {
        HashMap m=new HashMap();
        m.put(100,"Hello");
        m.put(101,"Geeks");
        m.put(102,"Geeks");
        m.put(null,"World");
        System.out.println(m);
    }
} 

producción:

{null=World, 100=Hello, 101=Geeks, 102=Geeks}

Usando ConcurrentHashMap

//Java Program to illustrate HashMap behaviour
import java.util.concurrent.*;
class ConcurrentHashMapDemo
{
    public static void main(String[] args)
    {
        ConcurrentHashMap m=new ConcurrentHashMap();
        m.put(100,"Hello");
        m.put(101,"Geeks");
        m.put(102,"Geeks");
        m.put(null,"World");
        System.out.println(m);
    }
} 

Producción:

Exception in thread "main" java.lang.NullPointerException