How to Synchronize HashMap inward Java alongside Example

HashMap is non synchronized, which way y'all cannot usage it on multi-threaded Java programme without external synchronization. In approximately other word, if y'all part ane event of HashMap betwixt multiple threads, each is either adding, removing or updating entries thence it's possible that HashMap loss its construction too non comport equally expected. If y'all bring read my earlier article almost HashMap, y'all know that during re-sizing its possible that HashMap exposed to multiple threads, may goal upwards inwards an infinite loop. In club to avoid this, unremarkably ane HashMap event is used past times ane thread, sharing of HashMap event is non allowed, but if y'all bring to part HashMap too at that spot is no selection to avoid that, y'all tin e'er synchronize HashMap inwards Java. Ofcourse this volition touching on the functioning too likely trim down the speed of HashMap equally synchronized method is e'er slower than non-synchronized one. In this tutorial, nosotros volition acquire how nosotros tin synchornize HashMap inwards Java.

Synchronizing HashMap inwards Java amongst Example

In this example, nosotros bring a HashMap<Integer, String> it is having integer keys too String type values. In club to synchronize it nosotros are using Collections.synchronizedMap(hashmap) it returns a thread-safe map backed upwards past times the specified HashMap. In club to guarantee series access, it is critical that all access to the backing map is accomplished through the returned map.

It is likewise mandatory that the user manually synchronizes on the returned map when iterating over whatever of its collection views:

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

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

threaded Java programme without external synchronization How to Synchronize HashMap inwards Java amongst Example

Failure to follow this advice may resultant inwards non-deterministic behavior. Also, the returned map volition endure serializable if the specified map is serializable. Here is consummate code illustration of how to synchronized HashMap inwards Java. You tin run it inwards your favorite Java IDE or from the ascendence prompt equally y'all wish, but brand certain y'all shop this course of written report inwards 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 programme demonstrate, how to synchronize HashMap inwards Java.   *   * @author WINDOWS 8  */  public class HashMapSynchronizationDemo{      public static void main(String args[]) {                  // HashMap amongst mapping containing solid reason too 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 inwards Java         currencies = Collections.synchronizedMap(currencies);                  // Make certain to synchronize Map piece Iterating          // getting cardinal laid upwards tin endure exterior synchronized block         Set<String> keySet = currencies.keySet();                             // Synchronizing on HashMap, non on Set         synchronized(currencies) {               Iterator<String> itr = keySet.iterator(); // Must endure inwards synchronized block                         while (itr.hasNext()){                 System.out.println(itr.next());             }         }             }  }  Output USA Canada HongKong England Australia

That's all almost how create y'all synchronize HashMap inwards Java. Collections.synchronizedMap() is a useful method to hit this but y'all likewise bring ameliorate options available inwards Java. For example, if y'all know from the kickoff that your HashMap volition endure shared betwixt multiple threads thence why non usage ConcurrentHashMap, which is peculiarly designed for such use. Unfortunately, if y'all bring non even thence on Java 1.5 thence at that spot is Hashtable which provides similar functionality similar synchronized HashMap.

Further Learning
Java Fundamentals: Collections
From Collections to Streams inwards Java 8 Using Lambda Expressions
Grokking Algorithms past times Aditya Bhargava
Java Programming Interview Exposed past times Makham

If y'all similar this article too dear to explore to a greater extent than inwards the footing of HashMap, banking enterprise fit out following;

What is the deviation betwixt Hashtable too ConcurrentHashMap inwards Java? (difference)
How acquire method of HashMap plant inwards Java? (answer)
How to traverse HashMap inwards Java? (example)
How to variety HashMap based upon keys too values inwards Java? (solution)
What is the deviation betwixt Hashtable too HashMap inwards Java? (answer)
Difference betwixt HashSet too HashMap inwards Java? (answer)
What is the deviation betwixt ArrayList too HashMap? (difference)
How HashSet internally plant inwards Java? (answer)
How to convert Map to List inwards Java? (solution)
Difference betwixt HashMap too LinkedHashMap inwards Java? (answer)