In this article, we will discuss difference between SynchronizedMap and ConcurrentHashMap classes in detail i.e.; ConcurrentHashMap v/s SynchronizedMap

Lets us move on and discuss key differences between synchronized version of Map and ConcurrentHashMap

1. SynchronizedMap v/s ConcurrentHashMap :

SynchronizedMap	ConcurrentHashMap
This is thread-safe version of Map	ConcurrentHashMap is newly introduced thread-safe class
Only one thread is allowed to operate on synchronized map, by locking over complete map object	Multiple threads are allowed to operate on concurrent map, by locking over portion of map object i.e.; at segment-level or bucket-level
Every operations like read and update requires lock over complete map object before operating on map object	Read operation doesn’t require lock but update operation require definitely lock on the portion of map object i.e.; at segment-level or bucket-level
While one thread iterating Map items, if any other thread tries to modify Map items then ConcurrentModificationException is thrown	While one thread iterating ConcurrentHashMap items, other thread are happily can modify Map items   And it never throws ConcurrentModificationException
That’s it is fail-fast iterator	That’s it is fail-safe iterator
NULL insertion is possible for key but maximum of one null key and any number of null values against any key	NULL insertion isn’t allowed for both keys and values
This is introduced in original collection framework in Java 1.2 version	This is introduced in Java 1.5 version

Q) When to use SynchronizedMap ?

• This is generally used to convert map object into thread-safe Map object
• But only one thread is allowed to operate on map object, as lock is required over complete map object
• So, performance degrades comparatively in a multi-threaded environment
• So, use this only when it is required to convert into thread-safe version of Map object

Q) When to use ConcurrentHashMap ?

• This is the best suit to store key-value pairs in a multi-threaded environment
• And also one thread iterating never stops other threads to modify
• And it never throws ConcurrentModificationException

2. ConcurrentHashMap v/s SynchronizedMap

• there is always a catch between performance and thread-safety
• Choose wisely for your requirement

Related Articles:

• Java 5 – Introduction to Concurrent Collection
• Java 5 – ConcurrentMap interface
• Java 5 – ConcurrentHashMap class with example
• Java 5 – ConcurrentHashMap with Read and Update operations simultaneously
• Java 5 – HashMap v/s ConcurrentHashMap
• Java 5 – ConcurrentHashMap v/s SynchronizedMap
• Java 5 – Concurrent Collection Interview question and answers

References:

• https://docs.oracle.com/javase/tutorial/collections/intro/
• https://docs.oracle.com/javase/tutorial/collections/interfaces/collection.html
• https://docs.oracle.com/javase/7/docs/api/java/util/Collection.html
• https://docs.oracle.com/javase/7/docs/api/java/util/Map.html
• https://docs.oracle.com/javase/7/docs/api/java/util/Map.Entry.html
• https://docs.oracle.com/javase/tutorial/collections/interfaces/map.html
• https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html
• https://docs.oracle.com/javase/7/docs/api/java/util/Collections.html
• https://docs.oracle.com/javase/tutorial/essential/concurrency/collections.html
• https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ConcurrentMap.html
• https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ConcurrentHashMap.html

Happy Coding !!
Happy Learning !!