ConcurrentHashMap

📋 Quick Reference

Property	Value
Type	Thread-safe hash map
Get/Put	O(1) average, thread-safe
Concurrency	Lock striping (segments)
Null	Neither keys nor values can be null
Consistency	Weakly consistent iteration
Best For	Multi-threaded caching, shared state

One-liner: Thread-safe HashMap using lock striping for high-concurrency reads and writes.

🎮 Interactive Visualizer

Watch how ConcurrentHashMap handles concurrent operations:

ConcurrentHashMap
Segment LocksLock-free Reads
T1
T2
T3
1 / 0
⚡ Why ConcurrentHashMap?
synchronized HashMap
❌ Single lock for entire map
All threads wait for one lock
ConcurrentHashMap
✓ Segment-level locking
Threads work in parallel on different segments
get() never blocks • put() only locks one segment • Much better concurrency!
Segments (independent locks)
Key insight: Multiple threads can write to different segments simultaneously. Reads never block!
Pseudocode
1// ConcurrentHashMap (Java 8+)
2put(key, value):
3  hash = spread(key.hashCode())
4  segment = hash & (n-1)
5  synchronized(segment):
6    // Only this segment locked
7    bucket.add(key, value)
8 
9get(key):
10  // No lock needed!
11  // Volatile reads ensure visibility
12  return bucket.get(key)
Variables
—
Keyboard Shortcuts
P Play / Pause
[ Step back
] Step forward
R Reset
Speed
Active segment
Active segment
Locked
Locked
Unlocked
Unlocked
P · [ ] · R
Loading visualizer...

Try these operations:

See multiple threads accessing different segments
Watch lock acquisition on writes
Observe lock-free reads
Compare with synchronized HashMap bottleneck

🔧 Key Operations

Creating

JAVA(8 lines)
Code
Loading syntax highlighter...

Basic Operations (Thread-Safe)

JAVA(13 lines)
Code
Loading syntax highlighter...

Atomic Compound Operations

JAVA(14 lines)
Code
Loading syntax highlighter...

Bulk Operations (Java 8+)

JAVA(13 lines)
Code
Loading syntax highlighter...

📊 Complexity & Concurrency

Operation	Time	Thread Safety
`get(key)`	O(1)	Lock-free read
`put(key, val)`	O(1)	Per-bucket lock
`remove(key)`	O(1)	Per-bucket lock
`putIfAbsent`	O(1)	Atomic
`compute*`	O(1)	Atomic within bucket
`size()`	O(n)	Approximate

Lock Striping (Java 7)

Segments (each with own lock):
[Segment 0] → bucket → bucket → bucket
[Segment 1] → bucket → bucket → bucket
[Segment 2] → bucket → bucket → bucket
...

Concurrent writes to different segments don't block each other.

Node-Level Locking (Java 8+)

Buckets (synchronized on first node):
[0] → Node → Node → Node  ← lock on first node
[1] → Node → Node         ← separate lock
[2] → null                ← no lock needed
...

Finer-grained: lock per bucket, not segment.

✅ When to Use ConcurrentHashMap

Good Use Cases

Shared caches - read-heavy with occasional updates
Counters/stats - atomic increment with merge()
Concurrent config - shared configuration
Thread-safe lookup - replace synchronized HashMap

Avoid When

Single-threaded - HashMap is faster (no sync overhead)
Need null keys/values - CHM prohibits nulls
Need consistent iteration - iterator is weakly consistent
Full atomicity needed - compound ops may need external sync

🔄 ConcurrentHashMap vs Alternatives

Feature	HashMap	Hashtable	synchronizedMap	ConcurrentHashMap
Thread-safe	No	Yes	Yes	Yes
Null keys	Yes	No	Yes	No
Lock scope	N/A	Entire map	Entire map	Per-bucket
Performance	Best	Poor	Poor	Good
Recommended	Single thread	Never	Rarely	Multi-thread

JAVA(8 lines)
Code
Loading syntax highlighter...

🧩 Common Patterns

Thread-Safe Counter

JAVA(8 lines)
Code
Loading syntax highlighter...

Caching with computeIfAbsent

JAVA(7 lines)
Code
Loading syntax highlighter...

Check-Then-Act (Atomically)

JAVA(10 lines)
Code
Loading syntax highlighter...

⚠️ Common Pitfalls

1. Using Null Keys/Values

JAVA(6 lines)
Code
Loading syntax highlighter...

2. Non-Atomic Check-Then-Act

JAVA(7 lines)
Code
Loading syntax highlighter...

3. Blocking in compute()

JAVA(8 lines)
Code
Loading syntax highlighter...

4. Relying on size() for Exact Count

JAVA(8 lines)
Code
Loading syntax highlighter...

5. Iterating with Modifications

JAVA(5 lines)
Code
Loading syntax highlighter...

🎤 Interview Tips

Q: How does ConcurrentHashMap achieve thread safety?

"

In Java 8+, it uses lock-free reads and synchronized blocks on individual buckets for writes. Each bucket's first node acts as a lock, allowing concurrent access to different buckets.

Q: Why doesn't ConcurrentHashMap allow null?

"

Null would be ambiguous: does get() returning null mean "key not present" or "value is null"? HashMap uses containsKey() to distinguish, but that's not atomic in CHM.

Q: What's weakly consistent iteration?

"

Iterators reflect the state of the map at some point during or after creation. They won't throw ConcurrentModificationException, but may or may not reflect concurrent updates.

Q: ConcurrentHashMap vs synchronized HashMap?

"

CHM allows concurrent reads without locking and uses fine-grained locks for writes (per-bucket). synchronizedMap locks the entire map for every operation, creating a bottleneck.

Previous: Part 13: Dynamic Programming

Next: Part 15: BlockingQueue

Visualizer: ConcurrentHashMap from @tomaszjarosz/react-visualizers

📋 Quick Reference

🎮 Interactive Visualizer

ConcurrentHashMap

🔧 Key Operations

Creating

Basic Operations (Thread-Safe)

Atomic Compound Operations

Bulk Operations (Java 8+)

📊 Complexity & Concurrency

Lock Striping (Java 7)

Node-Level Locking (Java 8+)

✅ When to Use ConcurrentHashMap

Good Use Cases

Avoid When

🔄 ConcurrentHashMap vs Alternatives

🧩 Common Patterns

Thread-Safe Counter

Caching with computeIfAbsent

Check-Then-Act (Atomically)

⚠️ Common Pitfalls

1. Using Null Keys/Values

2. Non-Atomic Check-Then-Act

3. Blocking in compute()

4. Relying on size() for Exact Count

5. Iterating with Modifications

🎤 Interview Tips

📚 Series Navigation

Tags:

ConcurrentHashMap