1. What is ConcurrentHashMap? How does it work?
ConcurrentHashMap is a thread-safe hash table implementation in Java. Unlike HashMap, ConcurrentHashMap supports multiple threads to access and modify the hash table at the same time without any additional synchronization mechanism.
The working principle of ConcurrentHashMap is similar to that of HashMap. It uses a hash function to map keys to bucket index positions, and uses data structures such as linked lists or red-black trees to resolve hash collisions. However, ConcurrentHashMap uses a segment lock (segment lock) to restrict that only one thread can modify a specific bucket at a time.
2. What is the difference between ConcurrentHashMap and HashMap?
Both ConcurrentHashMap and HashMap are hash table implementations, but there are some key differences between them. The main differences are as follows:
- Thread Safety: ConcurrentHashMap is thread safe while HashMap is not.
- Performance: In the case of high concurrency, the performance of ConcurrentHashMap is usually better than HashMap, because it allows multiple threads to access the hash table at the same time without additional synchronization.
- Null keys and null values: ConcurrentHashMap does not support null keys and null values, while HashMap does.
| JDK1.7 |
JDK1.8 |
|
| accomplish |
hashEntry+segment |
Node+CAS+Synchronized |
| Lock |
Segment inherits ReetrantLock |
Synchronized |
| storage |
array + linked list |
Array + linked list + red-black tree |
| Linked list more than 8 |
array |
red black tree |
| Interpolation |
head insertion |
tail plugging |
3. What is the segment lock in ConcurrentHashMap? How does it ensure thread safety?
The segment lock in ConcurrentHashMap is a lock design pattern that divides the hash table into multiple parts (segments), each of which has an independent lock. When you need to modify the key-value pairs in a specific bucket, you only need to lock the corresponding segment, not the entire hash table.
Since each segment has its own lock, multiple threads can access and modify different segments at the same time, improving concurrency performance. This ensures that only one thread can modify key-value pairs in the same segment at any time, thus ensuring thread safety.
4. What is the expansion mechanism of ConcurrentHashMap?
The expansion mechanism of ConcurrentHashMap is similar to that of HashMap. When the number of key-value pairs stored in ConcurrentHashMap exceeds the load factor multiplied by the capacity of the hash table, ConcurrentHashMap will automatically expand. When expanding, ConcurrentHashMap will create a new bucket array, and copy all key-value pairs to the new bucket by rehashing. Unlike HashMap, the expansion of ConcurrentHashMap will not block the access of other threads. During scaling, ConcurrentHashMap will add new key-value pairs to new buckets instead of old buckets. This ensures that concurrent access is still possible during scaling.