Thread-Safe Map Implementations

When working with maps in multi-threaded environments, several thread-safe implementations are available:

• Collections.synchronizedMap(Map) wrapper
• Hashtable
• ConcurrentHashMap

Among these, ConcurrentHashMap generally offers the best performance and concurrency characteristics.

Collections.synchronizedMap Implementation

The synchronized map wrapper works by:

1. Maintaining an internal map object
2. Using a mutex lock object for synchronization
3. Applying locks on all map operations

Map<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>());

Hashtable Characteristics

Key aspects of Hashtable:

• Thread-safe through synchronized methods
• Doesn't allow null keys or values
• Inherits from Dictionary class (legacy)
• Default initial capacity of 11
• Grows by doubling capacity + 1
• Uses fail-safe iteration

Hashtable<String, Integer> table = new Hashtable<>();

ConcurrentHashMap Implementation

JDK 1.7 Architecture

• Segmented array structure
• Each segment acts as independent hash table
• Segment extends ReentrantLock
• Concurrent access to different segments

JDK 1.8 Improvements

• Removed segment locking
• Uses CAS + synchronized per bucket
• Node replaces HashEntry
• Introduces tree bins for long chains
• Volatile variables for visibility

ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();

Performance Considerations

• ConcurrentHashMap provides better concurrency than Hashtable
• Read operations don't require locking
• Write operations use fine-grained locking
• CAS operations minimize blocking
• Size operatinos may require traversal

Thread Safety Mechanisms

1. Volatile Variables: Ensure visibility of changes across threads
2. CAS Operations: Atomic compare-and-swap for lock-free updates
3. Synchronized Blocks: Protect bucket-level modifications
4. Immutable Objects: Used during resizing operations

Common Interview Questions

• How does ConcurrentHashMap achieve thread safety?
• What are the differences between Hashtable and ConcurrentHashMap?
• Explain the CAS mechanism and its limittaions
• Describe the synchronized optimization in JDK 1.8
• What is fail-fast iteration versus fail-safe?
• How does ConcurrentHashMap handle resizing?
• What are the performance implications of different map implementations?