Thursday, September 4, 2025
HomeLanguagesJavaDifference between HashMap and ConcurrentHashMap

Difference between HashMap and ConcurrentHashMap

HashMap is the Class which is under Traditional Collection and ConcurrentHashMap is a Class which is under Concurrent Collections, apart from this there are various differences between them which are:

  • HashMap is non-Synchronized in nature i.e. HashMap is not Thread-safe whereas ConcurrentHashMap is Thread-safe in nature.
  • HashMap performance is relatively high because it is non-synchronized in nature and any number of threads can perform simultaneously. But ConcurrentHashMap performance is low sometimes because sometimes Threads are required to wait on ConcurrentHashMap.
  • While one thread is Iterating the HashMap object, if other thread try to add/modify the contents of Object then we will get Run-time exception saying ConcurrentModificationException.Whereas In ConcurrentHashMap we wont get any exception while performing any modification at the time of Iteration.
  • Using 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);
        }
    }

    
    

    Output:

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

Using 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);
    }
}


Output:

100=A
101=B
102=C
103=D
{100=A, 101=B, 102=C, 103=D}
  • In HashMap, null values are allowed for key and values, whereas in ConcurrentHashMap null value is not allowed for key and value, otherwise we will get Run-time exception saying NullPointerException.
  • Using 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);
        }
    } 

    
    

    output:

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

    Using 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);
        }
    } 

    
    

    Output:

    Exception in thread "main" java.lang.NullPointerException
    
  • HashMap is introduced in JDK 1.2 whereas ConcurrentHashMap is introduced by SUN Microsystem in JDK 1.5.
  • RELATED ARTICLES

    Most Popular

    Dominic
    32264 POSTS0 COMMENTS
    Milvus
    81 POSTS0 COMMENTS
    Nango Kala
    6632 POSTS0 COMMENTS
    Nicole Veronica
    11800 POSTS0 COMMENTS
    Nokonwaba Nkukhwana
    11860 POSTS0 COMMENTS
    Shaida Kate Naidoo
    6749 POSTS0 COMMENTS
    Ted Musemwa
    7025 POSTS0 COMMENTS
    Thapelo Manthata
    6698 POSTS0 COMMENTS
    Umr Jansen
    6718 POSTS0 COMMENTS