Skip to content
Related Articles

Related Articles

Difference between HashMap and ConcurrentHashMap

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 06 Aug, 2019

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!