Yige

Yige

Build
HomeArchives作品集

ConcurrentHashMap and Hashtable

#Java基础45
AI Translation
This post is translated from Chinese into English through AI.View Original
AI-generated summary
**ConcurrentHashMap vs. Hashtable** **ConcurrentHashMap:** - **JDK 1.5 Implementation:** Utilizes segment locks (extends ReentrantLock) for thread safety. It divides the map into segments, each with its own lock, allowing concurrent access to different segments. Default is 16 segments, improving efficiency by 16 times compared to Hashtable. - **JDK 1.8 Implementation:** Employs CAS (Compare-And-Swap) and synchronized for concurrency. It further refines locking by using finer granularity than segments. It first attempts to insert a head node without locking; if that fails, it uses synchronized to lock the head node for further operations, enhancing performance over JDK 1.5. **Hashtable:** - A thread-safe key-value data structure, existing since JDK 1.0. - Inherits from the deprecated Dictionary class, while HashMap inherits from AbstractMap. - Does not support null keys or values, unlike HashMap, which allows one null key and multiple null values. - Every method is synchronized, making it thread-safe, while HashMap is not. - Uses both Iterator and Enumeration for iteration. - Default initial size is 11, expanding to 2n+1; HashMap starts at 16 and doubles its size. - Hash calculation differs: Hashtable uses the object's hashCode directly, while HashMap applies a perturbation function. **Difference from Collections.synchronizedMap():** - `synchronizedMap` is a private static inner class that provides a synchronized wrapper around a Map. **Comparison:** - Hashtable locks all methods with synchronized and uses a mutex object for thread safety, while ConcurrentHashMap allows more concurrent access through segmented locking.

ConcurrentHashMap && Hashtable#

How does ConcurrentHashMap achieve thread safety?#

Implementation in JDK1.5#

Uses Segment (extends ReentrantLock) to implement
By using segmented locking technique, ConcurrentHashMap locks the storage in segments, and assigns a lock (segment) to each segment of data. When one thread occupies a lock (segment) to access a segment of data, other segments can still be accessed by other threads. It defaults to 16 segments, which improves efficiency by 16 times compared to Hashtable.

Implementation in JDK1.8#

Uses CAS and synchronized to ensure concurrent safety
The implementation in JDK8 also follows the idea of lock separation, dividing locks into finer segments than segments (JDK1.5). As long as there is no hash collision, there will be no concurrent lock acquisition. It first uses the lock-free operation CAS to insert the head node; if the insertion fails, it indicates that another thread has already inserted the head node, and it loops to perform the operation again (similar to a spin lock). If the head node already exists, it acquires the head node lock through synchronized to perform subsequent operations, further improving performance compared to segment locking.

Hashtable#

Hashtable is also a thread-safe key-value data structure.

Comparison with HashMap:#

  1. Hashtable has existed since JDK1.0, while HashMap was introduced in JDK1.2.
  2. Hashtable inherits from the Dictionary class (deprecated), while HashMap inherits from the AbstractMap class.
  3. Hashtable does not support null keys or null values, whereas HashMap allows null as a key (only one such key) and can have one or more keys corresponding to null values.
  4. Hashtable is thread-safe, as every method includes the synchronized method, while HashMap is not thread-safe.
  5. Both Hashtable and HashMap use Iterator, but due to historical reasons, Hashtable also uses Enumeration.
  6. The default initial size of Hashtable is 11, and each time it expands, the capacity becomes 2n+1 of the original. The default initial size of HashMap is 16, and each time it expands, the capacity doubles.
  7. The method of calculating hash values differs: Hashtable directly uses the object's hashCode, while HashMap also uses a perturbation function.

Difference from Collections.synchronizedMap()#

synchronizedMap is a private static inner class of Collections, which can be obtained through the Collections.synchronizedMap(Map) method and upcast to a Map object.

Comparative Analysis:

  • Hashtable locks all methods using the synchronized keyword.
  • It has an Object type mutex member, using the synchronize keyword to lock the mutex for thread-safe methods.
Loading...
Ownership of this post data is guaranteed by blockchain and smart contracts to the creator alone.