One more difference that I can find at the implementation of both the classes is as follows:
? The Hashtable
class has all its methods synchronized i.e. the locking is done at the method level and hence one can say that the mutex is always at the Hashtable
object (this
) level.
? The method Collections.synchronizedMap(Map)
returns an instance of SynchronizedMap
which is an inner class to the Collections
class. This class has all its methods in a Synchronized
block with a mutex. The difference lies in the mutex here. The inner class SynchronizedMap
has two constructors, one which takes only Map
as an argument and another which takes a Map
and an Object
(mutex) as an argument. By default if one uses the first constructor of passing only a Map
, this
is used as a mutex. Though, the developer is allowed to pass another object of mutex as a second argument by which the lock on the Map
methods would be only on that Object
and hence less restrictive than Hashtable
.
? Hence, Hashtable
uses method level synchronization but Collections.synchronizedMap(Map)
provides a flexibility to developer lock on provided mutex with Synchronized
block.
与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…