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}
  • En HashMap, se permiten valores nulos para clave y valores, mientras que en ConcurrentHashMap no se permiten valores nulos para clave y valor; de lo contrario, obtendremos una excepción en tiempo de ejecución que dice NullPointerException.
  • 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
    
  • HashMap se presenta en JDK 1.2, mientras que ConcurrentHashMap lo presenta SUN Microsystem en JDK 1.5.
  • Publicación traducida automáticamente

    Artículo escrito por Bishal Kumar Dubey y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *