ConcurrentHashMap vs Synchronized HashMap

Question

What is the difference between using the wrapper class  SynchronizedMap  on a HashMap and ConcurrentHashMap     Is it just being able to modify the HashMap while iterating it  ConcurrentHashMap

User · Answer

As per java doc s     Hashtable and Collections synchronizedMap new HashMap    are   synchronized  But ConcurrentHashMap is  concurrent         A concurrent collection is thread-safe  but not governed by a single exclusion lock        In the particular case of ConcurrentHashMap  it safely permits   any number of concurrent reads as well as a tunable number of   concurrent writes   Synchronized  classes can be useful when you need   to prevent all access to a collection via a single lock  at the   expense of poorer scalability        In other cases in which multiple   threads are expected to access a common collection   concurrent    versions are normally preferable  And unsynchronized collections are   preferable when either collections are unshared  or are accessible   only when holding other locks

User · Answer

Methods on SynchronizedMap hold the lock on the object  whereas in ConcurrentHashMap there s a concept of  lock striping  where locks are held on buckets of the contents instead  Thus improved scalability and performance

User · Answer

SynchronizedMap and ConcurrentHashMap are both thread safe class and can be used in multithreaded application  the main difference between them is regarding how they achieve thread safety  SynchronizedMap acquires lock on the entire Map instance   while ConcurrentHashMap divides the Map instance into multiple segments and locking is done on those

User · Answer

ConcurrentHashMap uses finer-grained locking mechanism known as lock stripping to allow greater degree of shared access  Due to this it provides better concurrency and scalability   Also iterators returned for ConcurrentHashMap are weakly consistent instead of fail fast technique used by Synchronized HashMap

User · Answer

ConcurrentHashMap is thread safe without synchronizing the whole map  Reads can happen very fast while write is done with a lock

User · Answer

ConcurrentHashMap allows concurrent access to data  Whole map is divided into segments    Read operation ie  get Object key  is not synchronized even at segment level    But write operations ie  remove Object key   get Object key  acquire lock at segment level  Only part of whole map is locked  other threads still can read values from various segments except locked one   SynchronizedMap on the other hand  acquire lock at object level  All threads should wait for current thread irrespective of operation Read Write

User · Answer

Synchronized HashMap   Each method is synchronized using an object level lock  So the get and put methods on synchMap acquire a lock   Locking the entire collection is a performance overhead  While one thread holds on to the lock  no other thread can use the collection    ConcurrentHashMap was introduced in JDK 5   There is no locking at the object level The locking is at a much finer granularity  For a ConcurrentHashMap  the locks may be at a hashmap bucket level   The effect of lower level locking is that you can have concurrent readers and writers which is not possible for synchronized collections  This leads to much more scalability   ConcurrentHashMap does not throw a ConcurrentModificationException if one thread tries to modify it while another is iterating over it    This article Java 7  HashMap vs ConcurrentHashMap  is a very good read  Highly recommended

User · Answer

A simple performance test for ConcurrentHashMap vs Synchronized HashMap   The test flow is calling put in one thread and calling get in three threads on Map concurrently  As  trshiv said  ConcurrentHashMap has higher throughput and speed for whose reading operation without lock  The result is when operation times is over 10 7  ConcurrentHashMap is 2x faster than Synchronized HashMap

User · Answer

ConcurrentHashMap    1 Both maps are thread-safe implementations of the Map interface   2 ConcurrentHashMap is implemented for higher throughput in cases where high concurrency is expected     3  There is no locking in object level     Synchronized Hash Map   1  Each method is synchronized using an object level lock

User · Answer

Both are synchronized version of HashMap  with difference in their core functionality and their internal structure   ConcurrentHashMap consist of internal segments which can be viewed as independent HashMaps  Conceptually  All such segments can be locked by separate threads in high concurrent executions  So  multiple threads can get put key-value pairs from ConcurrentHashMap without blocking waiting for each other  This is implemented for higher throughput   whereas  Collections synchronizedMap    we get a synchronized version of HashMap and it is accessed in blocking manner  This means if multiple threads try to access synchronizedMap at same time  they will be allowed to get put key-value pairs one at a time in synchronized manner

User · Answer

Synchronized HashMap  Lock mechanism - It Locks the whole map  so Multiple threads can t access the map concurrently  So  performance is relatively less   2 Null key or Value - It will allow null as a key or value  3 Concurrent modification exception - Iterator return by synchronized map throws concurrent modification exception ConcurrentHashMap 1 Lock mechanism -Locks the portion  Concurrent hashmap allows concurrent read and write  So performance is relatively better than a synchronized map 2 Null key or Value - It doesn t allow null as a key or value  If you use it will throw java lang NullPointerException at Runtime  3 Concurrent modification exception - It doesn t throw concurrent modification exceptions  import java util Map  import java util concurrent ConcurrentHashMap   public class Ex ConcurrentHashMap        public static void main String   args                     Map lt String  String gt  map   new ConcurrentHashMap lt  gt             map put  quot one quot    quot one quot            map put  quot two quot    quot two quot            map put  quot three quot    quot three quot            System out println  quot 1st  map    quot  map           String key   null          for Map Entry lt String  String gt  itr   map entrySet                          key   itr getKey                if  quot three quot  equals key                                 map put  quot FOUR quot    quot FOUR quot                              System out println key  quot       quot  itr getValue                       System out println  quot 2nd  map    quot  map             map put  quot FIVE quot   null    java lang NullPointerException         map put null   quot FIVE quot     java lang NullPointerException         System out println  quot 3rd  map    quot  map             Synchronized HashMap Example import java util Collections  import java util HashMap  import java util Iterator  import java util Map  import java util Map Entry   public class Ex Synchronizedmap        public static void main String   args                     Map lt String  String gt  map   new HashMap lt  gt                      map put  quot one quot    quot one quot            map put  quot two quot    quot two quot            map put  quot three quot    quot three quot            map put  quot FOUR quot   null           map put null   quot FIVE quot                     System out println  quot map    quot  map                    Map lt String  String gt  map1                    Collections synchronizedMap map           System out println  quot map1    quot  map1                    String key   null          for Map Entry lt String  String gt  itr   map1 entrySet                          key   itr getKey                if  quot three quot  equals key                                 map1 put  quot ABC quot    quot ABC quot                              System out println key  quot       quot  itr getValue                                System out println  quot New Map     quot  map1                                      Iterator lt Entry lt String  String gt  gt  iterator   map1 entrySet   iterator            int i   0          while iterator hasNext                          if i    1                                map1 put  quot XYZ quot    quot XYZ quot                              Entry lt String  String gt  next   iterator next                System out println next getKey    quot      quot  next getValue                 i

User · Answer

We can achieve thread safety by using both ConcurrentHashMap and synchronisedHashmap  But there is a lot of difference if you look at their architecture    synchronisedHashmap      It will maintain the lock at the object level  So if you want to perform any operation like put get then you have to acquire the lock first  At the same time  other threads are not allowed to perform any operation  So at a time  only one thread can operate on this  So the waiting time will increase here  We can say that performance is relatively low when you are comparing with ConcurrentHashMap     ConcurrentHashMap      It will maintain the lock at the segment level  It has 16 segments and maintains the concurrency level as 16 by default  So at a time  16 threads can be able to operate on ConcurrentHashMap  Moreover  read operation doesn t require a lock  So any number of threads can perform a get operation on it        If thread1 wants to perform put operation in segment 2 and thread2 wants to perform put operation on segment 4 then it is allowed here  Means  16 threads can perform update put delete  operation on ConcurrentHashMap at a time       So that the waiting time will be less here  Hence the performance is relatively better than synchronisedHashmap

User · Answer

The short answer   Both maps are thread-safe implementations of the Map interface  ConcurrentHashMap is implemented for higher throughput in cases where high concurrency is expected   Brian Goetz s article on the idea behind ConcurrentHashMap is a very good read  Highly recommended

[java] ConcurrentHashMap vs Synchronized HashMap

Examples related to java

Examples related to core