How to Synchronize HashMap in Java? Collections.synchronizedMap() Example Tutorial (original) (raw)

Hello guys, if you have used HashMap class in Java before than you will know that HashMap is not synchronized, which means you cannot use it on multi-threaded Java programs without external synchronization. In other words, if you share an instance of HashMap between multiple threads, where each of them is either adding, removing or updating entries then it's possible that HashMap may lose its structure and not behave as expected. In simple words, exposing HashMap to multiple threads can corrupt the Map and you may not able to retrieve the data you want. If you have read my earlier article about HashMap, you know that during re-sizing its possible that HashMap exposed to multiple threads, may end up in an 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.

Of course, this will affect the performance and probably reduce the speed of HashMap as synchronized method is always slower than the non-synchronized one. In this tutorial, we will learn how we can synchronize 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 using Collections.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 synchronizes on the returned map when iterating over any of its collection views:

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

  ...

Set mySet = m.keySet(); // Needn't be in synchronized block ... synchronized(synchronizedHashMaps ) {
// Synchronizing on map instance, not set Iterator 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 be serializable if the specified map is serializable.

How to synchronize HashMap in Java

Collections.synchronizedMap() Example in Java

Here is a complete code example of how to synchronized HashMap in Java. You can run it in your favorite Java IDE or from the 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;

/**

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 the start that your HashMap will be shared between multiple threads then why not use ConcurrentHashMap, which is specially designed for such use.

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

P. S. - If you are working on legacy Java version like before Java 1.5 then there is Hashtable class which provides similar functionality to synchronized HashMap. More often than not you will be using ConcurrentHashMap rather than Synchronized HashMap in Java.