🟢 Junior Level

ConcurrentHashMap is a thread-safe Map for multi-threaded applications.

Unlike Collections.synchronizedMap(new HashMap<>()) (a single lock for the entire map), CHM allows many threads to work in parallel by locking only individual buckets.

Key difference from HashMap:

• HashMap: not thread-safe
• ConcurrentHashMap: thread-safe, no locks for reads

Map<String, Integer> map = new ConcurrentHashMap<>();

// Safe from multiple threads
map.put("A", 1);
map.get("A");  // → 1

// null is not allowed!
map.put("A", null);  // → NullPointerException!

Rule of thumb:

• Single thread or thread-local → HashMap
• Multiple threads reading and writing → ConcurrentHashMap
• Multiple threads only reading → HashMap is fine (after safe publication)

---

🟡 Middle Level

Evolution

Java 7: Segment Locking

Java 7 — historical reference, not used in modern code.

Map divided into 16 segments
  → Threads on different segments don't block each other
  → size() = locks ALL segments!

Java 8+: Node-level Locking

CAS for empty buckets (no locks!)
Synchronized only for collisions (per bucket!)
  → Maximum parallelism

Atomic operations

map.putIfAbsent(key, value);  // Insert if absent

map.computeIfAbsent(key, k -> new ArrayList<>())
   .add(value);  // Compute and insert

map.merge(key, 1, Integer::sum);  // Atomic update

Features

// ❌ null is not allowed!
map.put(key, null);  // → NullPointerException

// ⚠️ size() is approximate!
int size = map.size();  // May change immediately!

// ✅ mappingCount() for large collections
long count = map.mappingCount();  // > 2^31

// ✅ Iterators do NOT throw Exception
// → Weakly consistent
// → Weakly consistent = iterator sees data at creation time and may (but is not required to) see subsequent changes. Never throws ConcurrentModificationException.
for (var entry : map) { ... }  // Safe

---

🔴 Senior Level

Lock-free Reads

// get() WITHOUT locks!
// Through volatile fields:
//   table array → volatile
//   Node.val → volatile
//   Node.next → volatile

// Happens-Before guarantee:
// → Reader sees the latest write

CAS + Synchronized

CAS (Compare-And-Swap) — an atomic CPU instruction: “write the new value only if the current value equals the expected one.” Works without locks — if two threads write simultaneously, one succeeds, the other retries.

put(key, value):
  1. Bucket is empty → CAS (no locks!)
  2. Bucket is occupied → synchronized on HEAD
     → Only this bucket is locked
     → Others work in parallel

Parallel Resizing

On resize:
  → ForwardingNode in old buckets
  → Writer threads SEE ForwardingNode
  → Call helpTransfer() → HELP with resizing!

→ Distributed resize, no full lock

CounterCells

Instead of a single volatile size:
  → CounterCell array (like LongAdder)
  → Each thread increments ITS OWN cell
  → size() = sum of all cells

→ Minimal contention!

Compute pitfall

// ❌ Long-running operation in compute
map.computeIfAbsent(key, k -> {
    Thread.sleep(10000);  // Blocks the bucket for 10 seconds!
    return value;
});

// ❌ Recursive access → Deadlock!
map.computeIfAbsent(key1, k -> {
    return map.get(key2);  // May wait on the same bucket!
});

Java 21: Virtual Threads

synchronized in CHM may "pin" virtual threads
  → But critical sections are VERY short
  → Rarely a problem in practice

If it is a problem:
  → async-profiler will show blocked time

Production Experience

Real scenario: Bad hashCode

// All keys → one bucket
// → Synchronized on a single bucket
// → 100 threads waiting → 0 parallelism!

// Solution: rewrite hashCode()
// Result: +500% throughput

Best Practices

1. Default choice for concurrency
2. null is not allowed — protects against ambiguity
3. computeIfAbsent — atomic initialization
4. No long-running operations in compute
5. mappingCount() > size() for > 2^31 elements
6. Bad hashCode → the main enemy of parallelism
7. Weakly consistent iterators

Summary for Senior

• CAS for empty buckets, synchronized for collisions
• Lock-free reads through volatile
• Parallel resizing with helpTransfer()
• CounterCells = scalable counter
• compute → no long operations, no recursion
• null not allowed — a philosophical decision
• Bad hashCode → contention on a single bucket

---

🎯 Interview Cheat Sheet

Must know:

• ConcurrentHashMap — thread-safe Map, unlike HashMap it allows parallel work without a full map lock
• Java 8+: CAS for empty buckets (lock-free) + synchronized only on the bucket for collisions (instead of Segment locking from Java 7)
• Lock-free reads through volatile: table, Node.val, Node.next — get() without locks
• null not allowed (keys and values) — protects against ambiguity (null = key absent vs null = value)
• Iterators are weakly consistent — do not throw ConcurrentModificationException, may not see latest changes
• Parallel resizing: ForwardingNode + helpTransfer() — writer threads help with resizing
• CounterCells (like LongAdder) — each thread increments its own cell, size() = sum
• size() is approximate, mappingCount() for > 2^31 elements

Frequent follow-up questions:

• How does CHM differ from Collections.synchronizedMap? — synchronizedMap locks the ENTIRE map on every operation. CHM locks only one bucket (synchronized) or doesn’t lock at all (CAS).
• Why are null values not allowed in CHM? — To distinguish “key not present” (get = null) from “value is null”. In HashMap this is impossible, creating ambiguity.
• What happens with a long-running operation in computeIfAbsent? — The bucket is locked for the entire computation. Other threads writing to the same bucket will wait. Recursive access → deadlock.
• How does CHM resize without a full lock? — It places ForwardingNode in old buckets. Writer threads, seeing it, call helpTransfer() and help transfer data.

Red flags (DO NOT say):

• ❌ “CHM uses Segment locking” — that’s Java 7, Java 8+ uses node-level locking
• ❌ “CHM fully locks the map on write” — it locks only one bucket, others keep working
• ❌ “CHM supports null values” — no, NullPointerException for null keys and values
• ❌ “size() in CHM is exact” — it’s approximate, may change immediately after the call

Related topics:

• [[19. How does ConcurrentHashMap ensure thread-safety]]
• [[14. What is Map and what implementations exist]]
• [[20. What is CopyOnWriteArrayList]]
• [[15. Difference between HashMap, LinkedHashMap, and TreeMap]]