How to Synchronize HashMap in Java with Example

How to Synchronize HashMap in Java with Example

HashMap is not synchronized, which means you cannot use it on multi-threaded Java program without external synchronization. In another word, if you share one instance of HashMap between multiple thread, each is either adding, removing or updating entries then it's possible that HashMap loss its structure and not behave as expected. If you have read my earlier articleabout HashMap, you know that during re-sizing its possible that HashMap exposed to multiple thread, may end up in infinite loop.  In order to avoid this, usually one HashMap instance is used by one thread, sharing of HashMap instance is not allowed, but if you have to share HashMap and there is no option to avoid that, you can always synchronize HashMap in Java. Ofcourse this will affect the performance and probably reduce the speed of HashMap as synchronized method is always slower than non-synchronized one. In this tutorial, we will learn how we can synchornize HashMap in Java.

Synchronizing HashMap in Java with Example

In this example we have a HashMap<Integer, String> it is having integer keys and String type values. In order to synchronize it we are usingCollections.synchronizedMap(hashmap)  it returns a thread-safe map backed up by the specified HashMap. In order to guarantee serial access, it is critical that all access to the backing map is accomplished through the returned map. It is also mandatory that the user manually synchronize on the returned map when iterating over any of its collection views:

   Map<Integer, String> synchronizedHashMaps = Collections.synchronizedMap(newHashMap<>());

      ...
  Set<Integer>  mySet = m.keySet();  // Needn't be in synchronized block
      ...
  synchronized(synchronizedHashMaps ) {  // Synchronizing on map instance, not set
      Iterator<Integer> i = mySet.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
  }

Failure to follow this advice may result in non-deterministic behavior. Also the returned map will beserializable if the specified map is serializable. Here is complete code example of how to synchronized HashMap in Java. You can run it on your favorite Java IDE or from command prompt as you wish, just make sure you store this class in HashMapSynchronizationDemo.java file.

import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * This Java program demonstrate, how to synchronize HashMap in Java. 
 * 
 * @author WINDOWS 8
 */

public class HashMapSynchronizationDemo{

    public static void main(String args[]) {
        
        // HashMap with mapping containing country and their currency
        Map<String, String> currencies = new HashMap<String, String>();
        
        currencies.put("USA", "USD");
        currencies.put("England", "GBP");
        currencies.put("Canada", "CAD");
        currencies.put("HongKong", "HKD");
        currencies.put("Australia", "AUD");
        
        // Synchronizing HashMap in Java
        currencies = Collections.synchronizedMap(currencies);
        
        // Make sure to synchronize Map while Iterating 
        // getting key set can be outside synchronized block
        Set<String> keySet = currencies.keySet();  
        
        
        // Synchronizing on HashMap, not on Set
        synchronized(currencies) {  
            Iterator<String> itr = keySet.iterator(); // Must be in synchronized block            
            while (itr.hasNext()){
                System.out.println(itr.next());
            }
        }
       
    }

}

Output
USA
Canada
HongKong
England
Australia

That's all about how do you synchronize HashMap in Java. Collections.synchronizedMap() is a useful method to achieve this but you also have better options available in Java. For example, if you know from start that your HashMap will be shared between multiple threads then why not useConcurrentHashMap, which is especially designed for such use. Unfortunately, if you have not yet on Java 1.5 then there is Hashtable which provides similar functionality like synchronized HashMap.

If you like this article and love to explore more in the world of HashMap, check out following;

• Difference between Hashtable and ConcurrentHashMap in Java? (difference)
• How get method of HashMap works in Java? (answer)
• How to traverse HashMap in Java? (example)
• How to sort HashMap based upon keys and values in Java? (solution)
• What is difference between Hashtable and HashMap in Java? (answer)
• Difference between HashSet and HashMap in Java? (answer)
• What is difference between ArrayList and HashMap? (difference)
• How HashSet internally works in Java? (answer)
• How to convert Map to List in Java? (solution)
• Difference between HashMap and LinkedHashMap in Java? (answer)