ConcurrentHashMap is a thread-safe implementation of the Map interface designed for high concurrency scenarios. It provides better performance than synchronized HashMap by using sophisticated locking strategies.

1. Evolution and Architecture Overview

Historical Evolution:

• Java 1.5: Initial version using segment-based locking (16 segments)
• Java 8: Complete redesign using Node-based structure with fine-grained locking
• Java 11+: Further optimizations and performance improvements

Key Design Goals:

• Thread Safety: Allow concurrent reads and limited concurrent writes
• High Throughput: Minimize lock contention
• Scalability: Perform well under high concurrency
• Memory Consistency: Provide happens-before relationships

2. Java 8+ Internal Architecture

Core Data Structure:

// Simplified representation of ConcurrentHashMap internals
public class ConcurrentHashMap<K,V> {
// Main hash table - array of nodes
transient volatile Node<K,V>[] table;
// Next table to use during resizing
private transient volatile Node<K,V>[] nextTable;
// Base counter for size
private transient volatile long baseCount;
// Table initialization and resizing control
private transient volatile int sizeCtl;
// Node class representing hash table entries
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
volatile V val;
volatile Node<K,V> next;
// Constructors, methods...
}
// Special node types
static final class TreeNode<K,V> extends Node<K,V> { /* For balanced trees */ }
static final class ReservationNode<K,V> extends Node<K,V> { /* For compute methods */ }
static final class ForwardingNode<K,V> extends Node<K,V> { /* During resizing */ }
}

Hash Table Structure Visualization:

Table (Array of Buckets/Bins):
Index 0: [Node] → [Node] → [Node]  // Linked List or Tree
Index 1: [TreeBin] → TreeNode → TreeNode → TreeNode  // Balanced Tree
Index 2: null                     // Empty bucket
Index 3: [Node] → [Node]          // Short linked list
Index 4: [ForwardingNode]         // During resizing
...

3. Node Types and Bucket Organization

import java.util.concurrent.ConcurrentHashMap;
import java.lang.reflect.Field;
import java.util.Arrays;
public class ConcurrentHashMapInternals {
// Demonstration of different node types and bucket organization
public static class BucketOrganization {
public void demonstrateBucketStructures() {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
// Add entries to create different bucket structures
for (int i = 0; i < 100; i++) {
// Keys with same hash to create collisions
String key = "key-" + (i % 10); // 10 different keys, some will collide
map.put(key, i);
}
// Add more entries to trigger treeification
for (int i = 100; i < 200; i++) {
String key = "key-" + (i % 5); // More collisions
map.put(key, i);
}
System.out.println("Map size: " + map.size());
System.out.println("Load factor: 0.75 (default)");
System.out.println("Treeification threshold: 8");
System.out.println("Untreeification threshold: 6");
}
}
// Hash computation and bucket indexing
public static class HashMechanism {
// ConcurrentHashMap's spread function (simplified)
public static int spread(int h) {
return (h ^ (h >>> 16)) & 0x7fffffff;
}
// Bucket index calculation
public static int bucketIndex(int hash, int tableLength) {
return hash & (tableLength - 1);
}
public void demonstrateHashDistribution() {
String[] keys = {"apple", "banana", "cherry", "date", "elderberry", 
"fig", "grape", "honeydew", "ice cream", "juice"};
System.out.println("=== Hash Distribution Example ===");
int tableSize = 16; // Initial table size
for (String key : keys) {
int hashCode = key.hashCode();
int spreadHash = spread(hashCode);
int bucketIndex = bucketIndex(spreadHash, tableSize);
System.out.printf("Key: %-12s | Hash: %10d | Spread: %10d | Bucket: %2d%n",
key, hashCode, spreadHash, bucketIndex);
}
}
}
public static void main(String[] args) {
BucketOrganization org = new BucketOrganization();
org.demonstrateBucketStructures();
System.out.println();
HashMechanism hashMech = new HashMechanism();
hashMech.demonstrateHashDistribution();
}
}

4. Locking Mechanism and Concurrency Control

Fine-Grained Locking Strategy:

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.*;
import java.util.concurrent.locks.*;
public class LockingMechanism {
// Simplified representation of ConcurrentHashMap's locking
public static class ConcurrentHashMapLocking {
// synchronized on individual buckets (bin locking)
public V put(K key, V value) {
int hash = spread(key.hashCode());
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)
tab = initTable();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// No collision - use CAS for atomic insert
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
break;
}
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
// Collision - synchronize on the first node of the bucket
synchronized (f) {
if (tabAt(tab, i) == f) {
// Handle linked list or tree insertion
if (fh >= 0) {
// Linked list handling
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
// ... linked list traversal and update
}
}
else if (f instanceof TreeBin) {
// Tree handling
// ... tree insertion logic
}
}
}
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
break;
}
}
}
addCount(1L, binCount);
return null;
}
}
// CAS (Compare-And-Swap) operations demonstration
public static class CASOperations {
public void demonstrateCASMechanism() {
System.out.println("=== CAS Operations in ConcurrentHashMap ===");
// Simulate CAS operations used in ConcurrentHashMap
AtomicReferenceArray<Node<String, Integer>> simulatedTable = 
new AtomicReferenceArray<>(16);
// Initial state - empty bucket
int bucketIndex = 5;
System.out.println("1. Empty bucket: " + 
(simulatedTable.get(bucketIndex) == null));
// CAS operation to add first node
Node<String, Integer> newNode = new Node<>(
"key1".hashCode(), "key1", 100, null);
boolean casSuccess = simulatedTable.compareAndSet(
bucketIndex, null, newNode);
System.out.println("2. CAS operation to add first node: " + casSuccess);
System.out.println("   Bucket now contains: " + 
simulatedTable.get(bucketIndex));
// Another thread tries to add to same bucket
Node<String, Integer> competingNode = new Node<>(
"key2".hashCode(), "key2", 200, null);
boolean casFail = simulatedTable.compareAndSet(
bucketIndex, null, competingNode);
System.out.println("3. Competing CAS operation: " + casFail);
System.out.println("   Bucket still contains: " + 
simulatedTable.get(bucketIndex));
}
}
// Node class for demonstration
static class Node<K,V> {
final int hash;
final K key;
volatile V val;
volatile Node<K,V> next;
Node(int hash, K key, V val, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.val = val;
this.next = next;
}
@Override
public String toString() {
return "Node{key=" + key + ", value=" + val + "}";
}
}
public static void main(String[] args) {
CASOperations casOps = new CASOperations();
casOps.demonstrateCASMechanism();
}
}

5. Treeification Mechanism

Linked List to Tree Conversion:

import java.util.concurrent.ConcurrentHashMap;
import java.util.*;
import java.lang.reflect.*;
public class TreeificationMechanism {
public static class TreeificationDemo {
public void demonstrateTreeification() throws Exception {
ConcurrentHashMap<CustomKey, Integer> map = new ConcurrentHashMap<>(64, 0.75f, 1);
// Create keys that will hash to the same bucket
List<CustomKey> collisionKeys = generateCollisionKeys(20);
System.out.println("=== Treeification Process ===");
System.out.println("Initial table size: 64");
System.out.println("Treeification threshold: 8 nodes in a bucket");
System.out.println("Untreeification threshold: 6 nodes");
// Add keys to trigger treeification
for (int i = 0; i < collisionKeys.size(); i++) {
CustomKey key = collisionKeys.get(i);
map.put(key, i);
if (i == 7) {
System.out.println("\nAfter adding 8 elements (treeification threshold):");
inspectBucketStructure(map, key);
} else if (i == 15) {
System.out.println("\nAfter adding 16 elements (tree should be formed):");
inspectBucketStructure(map, key);
}
}
// Remove elements to trigger untreeification
for (int i = 0; i < 10; i++) {
map.remove(collisionKeys.get(i));
if (i == 9) {
System.out.println("\nAfter removing 10 elements (untreeification threshold):");
inspectBucketStructure(map, collisionKeys.get(19));
}
}
}
private List<CustomKey> generateCollisionKeys(int count) {
List<CustomKey> keys = new ArrayList<>();
// All keys will have same hash for demonstration
for (int i = 0; i < count; i++) {
keys.add(new CustomKey("key-" + i, 12345)); // Same hash for all
}
return keys;
}
private void inspectBucketStructure(ConcurrentHashMap<?, ?> map, Object key) 
throws Exception {
// Use reflection to inspect internal structure (for educational purposes)
Field tableField = ConcurrentHashMap.class.getDeclaredField("table");
tableField.setAccessible(true);
Object[] table = (Object[]) tableField.get(map);
int hash = key.hashCode();
int index = (table.length - 1) & hash;
Object firstNode = table[index];
if (firstNode == null) {
System.out.println("  Bucket " + index + ": EMPTY");
} else {
String nodeType = firstNode.getClass().getSimpleName();
System.out.println("  Bucket " + index + ": " + nodeType);
// Count elements in bucket
int elementCount = countElementsInBucket(firstNode);
System.out.println("  Elements in bucket: " + elementCount);
}
}
private int countElementsInBucket(Object firstNode) throws Exception {
// Simplified element counting
if (firstNode.getClass().getSimpleName().contains("TreeBin")) {
return 8; // Assume tree for demonstration
} else {
// Count linked list nodes
int count = 0;
Object current = firstNode;
while (current != null) {
count++;
Field nextField = current.getClass().getDeclaredField("next");
nextField.setAccessible(true);
current = nextField.get(current);
}
return count;
}
}
}
// Custom key class that allows controlling hash code
static class CustomKey {
private final String name;
private final int hashCode;
public CustomKey(String name, int hashCode) {
this.name = name;
this.hashCode = hashCode;
}
@Override
public int hashCode() {
return hashCode; // Controlled hash for collision demonstration
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
CustomKey that = (CustomKey) obj;
return Objects.equals(name, that.name);
}
@Override
public String toString() {
return name;
}
}
public static void main(String[] args) throws Exception {
TreeificationDemo demo = new TreeificationDemo();
demo.demonstrateTreeification();
}
}

6. Resizing Mechanism

Progressive Resizing Strategy:

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.*;
import java.util.*;
public class ResizingMechanism {
public static class ResizingDemo {
public void demonstrateResizing() {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>(16, 0.75f);
System.out.println("=== ConcurrentHashMap Resizing Process ===");
System.out.println("Initial capacity: 16");
System.out.println("Load factor: 0.75");
System.out.println("Resize threshold: 16 * 0.75 = 12 elements");
System.out.println();
// Track when resizing occurs
for (int i = 1; i <= 20; i++) {
map.put("key-" + i, i);
if (i == 12) {
System.out.println("After adding 12 elements (resize threshold):");
System.out.println("  - Table should be resizing or about to resize");
System.out.println("  - New capacity will be: 32");
} else if (i == 13) {
System.out.println("\nAfter adding 13 elements:");
System.out.println("  - Resizing in progress");
System.out.println("  - Some threads may help with transfer");
}
}
System.out.println("\nFinal state:");
System.out.println("  - Table capacity: 32");
System.out.println("  - Next resize at: 32 * 0.75 = 24 elements");
}
public void demonstrateMultiThreadedResizing() throws InterruptedException {
System.out.println("\n=== Multi-threaded Resizing ===");
ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>(8, 0.75f);
int threadCount = 4;
int elementsPerThread = 10;
List<Thread> threads = new ArrayList<>();
CountDownLatch startLatch = new CountDownLatch(1);
CountDownLatch endLatch = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
final int threadId = i;
Thread thread = new Thread(() -> {
try {
startLatch.await(); // Wait for all threads to be ready
for (int j = 0; j < elementsPerThread; j++) {
int key = threadId * 1000 + j;
map.put(key, "Value-" + key);
// Simulate some work
Thread.sleep(10);
}
endLatch.countDown();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
threads.add(thread);
thread.start();
}
// Start all threads simultaneously
startLatch.countDown();
// Monitor resizing
System.out.println("Starting " + threadCount + " threads, each adding " + 
elementsPerThread + " elements");
System.out.println("Initial capacity: 8, Resize threshold: 6");
// Wait for completion
endLatch.await();
System.out.println("All threads completed");
System.out.println("Final map size: " + map.size());
}
}
// Size counting mechanism
public static class SizeCounting {
public void demonstrateSizeCounting() {
System.out.println("\n=== Size Counting Mechanism ===");
// ConcurrentHashMap uses a distributed counting approach
System.out.println("Base counter + CounterCell[] for concurrent size counting");
System.out.println();
System.out.println("When contention is low:");
System.out.println("  - Use baseCount with CAS operations");
System.out.println();
System.out.println("When contention is high:");
System.out.println("  - Use CounterCell[] to distribute counting");
System.out.println("  - Each thread updates its own counter cell");
System.out.println("  - Total size = baseCount + sum(counterCells)");
System.out.println();
System.out.println("Benefits:");
System.out.println("  - Reduces contention on single counter");
System.out.println("  - Improves scalability under high concurrency");
}
}
public static void main(String[] args) throws InterruptedException {
ResizingDemo resizingDemo = new ResizingDemo();
resizingDemo.demonstrateResizing();
resizingDemo.demonstrateMultiThreadedResizing();
SizeCounting sizeCounting = new SizeCounting();
sizeCounting.demonstrateSizeCounting();
}
}

7. Iteration and Views

Weakly Consistent Iterators:

import java.util.concurrent.ConcurrentHashMap;
import java.util.*;
import java.util.concurrent.*;
public class IterationMechanism {
public static class IteratorDemo {
public void demonstrateWeaklyConsistentIteration() throws InterruptedException {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
// Populate initial data
for (int i = 0; i < 10; i++) {
map.put("key-" + i, i);
}
System.out.println("=== Weakly Consistent Iterator Demo ===");
// Start iteration in one thread
Thread iterationThread = new Thread(() -> {
System.out.println("Iteration started...");
int count = 0;
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println("Iterating: " + entry.getKey() + " = " + entry.getValue());
count++;
// Slow down iteration to allow concurrent modification
try {
Thread.sleep(100);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
if (count >= 5) {
System.out.println("... (stopping iteration output for brevity)");
break;
}
}
System.out.println("Iteration completed");
});
// Start modification in another thread
Thread modificationThread = new Thread(() -> {
try {
// Wait for iteration to start
Thread.sleep(50);
System.out.println("Modification thread: Adding new entries...");
map.put("key-new-1", 100);
map.put("key-new-2", 200);
Thread.sleep(200);
System.out.println("Modification thread: Removing some entries...");
map.remove("key-2");
map.remove("key-5");
Thread.sleep(200);
System.out.println("Modification thread: Updating entries...");
map.put("key-1", 999);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
iterationThread.start();
modificationThread.start();
iterationThread.join();
modificationThread.join();
System.out.println("\nFinal map contents:");
map.forEach((k, v) -> System.out.println(k + " = " + v));
}
public void demonstrateKeySetViews() {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
for (int i = 0; i < 5; i++) {
map.put("key-" + i, i);
}
System.out.println("\n=== KeySet Views ===");
// Different keySet views
Set<String> keySet = map.keySet();
Set<String> newKeySet = map.newKeySet(); // Java 8+
Set<String> mappedKeySet = map.keySet(100); // Java 8+ with mapped value
System.out.println("Standard keySet: " + keySet);
System.out.println("New keySet (independent): " + newKeySet);
System.out.println("Mapped keySet: " + mappedKeySet);
// Demonstrate view behavior
map.put("key-new", 99);
System.out.println("After adding to map - keySet: " + keySet);
System.out.println("After adding to map - newKeySet: " + newKeySet);
}
}
// Bulk operations
public static class BulkOperations {
public void demonstrateBulkOperations() {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
for (int i = 0; i < 10; i++) {
map.put("key-" + i, i);
}
System.out.println("\n=== Bulk Operations ===");
// forEach - parallel processing
System.out.println("forEach (sequential):");
map.forEach((k, v) -> System.out.println(k + " = " + v));
System.out.println("\nforEach (parallel, threshold 2):");
map.forEach(2, (k, v) -> System.out.println(Thread.currentThread().getName() + ": " + k));
// search - find first matching element
String foundKey = map.search(2, (k, v) -> v > 5 ? k : null);
System.out.println("\nSearch result (first value > 5): " + foundKey);
// reduce - combine all entries
Integer sum = map.reduce(2, (k, v) -> v, Integer::sum);
System.out.println("Reduce result (sum of values): " + sum);
}
}
public static void main(String[] args) throws InterruptedException {
IteratorDemo iteratorDemo = new IteratorDemo();
iteratorDemo.demonstrateWeaklyConsistentIteration();
iteratorDemo.demonstrateKeySetViews();
BulkOperations bulkOps = new BulkOperations();
bulkOps.demonstrateBulkOperations();
}
}

8. Performance Characteristics and Benchmarks

import java.util.concurrent.*;
import java.util.*;
import java.util.concurrent.atomic.*;
public class PerformanceAnalysis {
public static class ConcurrentHashMapBenchmark {
public void benchmarkOperations() throws InterruptedException {
int elementCount = 100000;
int threadCount = 8;
System.out.println("=== ConcurrentHashMap Performance Benchmark ===");
System.out.println("Elements: " + elementCount + ", Threads: " + threadCount);
System.out.println();
// Benchmark ConcurrentHashMap
benchmarkMap(new ConcurrentHashMap<>(), "ConcurrentHashMap", elementCount, threadCount);
// Benchmark synchronized HashMap for comparison
Map<String, Integer> synchronizedMap = Collections.synchronizedMap(new HashMap<>());
benchmarkMap(synchronizedMap, "SynchronizedHashMap", elementCount, threadCount);
// Benchmark Hashtable for comparison
benchmarkMap(new Hashtable<>(), "Hashtable", elementCount, threadCount);
}
private void benchmarkMap(Map<String, Integer> map, String mapName, 
int elementCount, int threadCount) throws InterruptedException {
System.out.println("Testing: " + mapName);
// Write performance
long writeTime = benchmarkWrites(map, elementCount, threadCount);
System.out.printf("  Write time: %,d ms%n", writeTime);
// Read performance
long readTime = benchmarkReads(map, elementCount, threadCount);
System.out.printf("  Read time:  %,d ms%n", readTime);
// Mixed operation performance
long mixedTime = benchmarkMixedOperations(map, elementCount, threadCount);
System.out.printf("  Mixed time: %,d ms%n", mixedTime);
System.out.println();
}
private long benchmarkWrites(Map<String, Integer> map, int elementCount, int threadCount) 
throws InterruptedException {
CountDownLatch startLatch = new CountDownLatch(1);
CountDownLatch endLatch = new CountDownLatch(threadCount);
AtomicLong totalTime = new AtomicLong();
for (int i = 0; i < threadCount; i++) {
final int threadId = i;
new Thread(() -> {
try {
startLatch.await();
long startTime = System.currentTimeMillis();
// Each thread writes a portion of elements
int elementsPerThread = elementCount / threadCount;
int start = threadId * elementsPerThread;
int end = (threadId == threadCount - 1) ? elementCount : start + elementsPerThread;
for (int j = start; j < end; j++) {
map.put("key-" + j, j);
}
long endTime = System.currentTimeMillis();
totalTime.addAndGet(endTime - startTime);
endLatch.countDown();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
}
startLatch.countDown();
endLatch.await();
return totalTime.get() / threadCount; // Average time per thread
}
private long benchmarkReads(Map<String, Integer> map, int elementCount, int threadCount) 
throws InterruptedException {
// First populate the map
for (int i = 0; i < elementCount; i++) {
map.put("key-" + i, i);
}
CountDownLatch startLatch = new CountDownLatch(1);
CountDownLatch endLatch = new CountDownLatch(threadCount);
AtomicLong totalTime = new AtomicLong();
for (int i = 0; i < threadCount; i++) {
new Thread(() -> {
try {
startLatch.await();
long startTime = System.currentTimeMillis();
Random random = new Random();
for (int j = 0; j < 10000; j++) {
int keyIndex = random.nextInt(elementCount);
map.get("key-" + keyIndex);
}
long endTime = System.currentTimeMillis();
totalTime.addAndGet(endTime - startTime);
endLatch.countDown();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
}
startLatch.countDown();
endLatch.await();
return totalTime.get() / threadCount;
}
private long benchmarkMixedOperations(Map<String, Integer> map, int elementCount, int threadCount) 
throws InterruptedException {
CountDownLatch startLatch = new CountDownLatch(1);
CountDownLatch endLatch = new CountDownLatch(threadCount);
AtomicLong totalTime = new AtomicLong();
for (int i = 0; i < threadCount; i++) {
final int threadId = i;
new Thread(() -> {
try {
startLatch.await();
long startTime = System.currentTimeMillis();
Random random = new Random();
for (int j = 0; j < 5000; j++) {
int operation = random.nextInt(100);
int keyIndex = random.nextInt(elementCount);
String key = "key-" + keyIndex;
if (operation < 60) { // 60% reads
map.get(key);
} else if (operation < 90) { // 30% writes
map.put(key, threadId);
} else { // 10% removes
map.remove(key);
}
}
long endTime = System.currentTimeMillis();
totalTime.addAndGet(endTime - startTime);
endLatch.countDown();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
}
startLatch.countDown();
endLatch.await();
return totalTime.get() / threadCount;
}
}
// Memory usage analysis
public static class MemoryAnalysis {
public void analyzeMemoryUsage() {
System.out.println("=== Memory Usage Analysis ===");
Runtime runtime = Runtime.getRuntime();
// Test with different map sizes
for (int size : new int[]{1000, 10000, 100000}) {
System.gc();
long memoryBefore = runtime.totalMemory() - runtime.freeMemory();
ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
for (int i = 0; i < size; i++) {
map.put(i, "Value-" + i);
}
long memoryAfter = runtime.totalMemory() - runtime.freeMemory();
long memoryUsed = memoryAfter - memoryBefore;
System.out.printf("Size: %,6d | Memory used: %,8d bytes | Per entry: %6.2f bytes%n",
size, memoryUsed, (double) memoryUsed / size);
}
}
}
public static void main(String[] args) throws InterruptedException {
ConcurrentHashMapBenchmark benchmark = new ConcurrentHashMapBenchmark();
benchmark.benchmarkOperations();
MemoryAnalysis memoryAnalysis = new MemoryAnalysis();
memoryAnalysis.analyzeMemoryUsage();
}
}

9. Best Practices and Common Pitfalls

import java.util.concurrent.ConcurrentHashMap;
import java.util.*;
import java.util.concurrent.atomic.*;
public class BestPractices {
public static class CorrectUsage {
// 1. Proper initialization with expected size
public void properInitialization() {
int expectedSize = 1000;
float loadFactor = 0.75f;
int concurrencyLevel = 16; // Number of concurrent update threads expected
ConcurrentHashMap<String, Integer> properlySizedMap = 
new ConcurrentHashMap<>(expectedSize, loadFactor, concurrencyLevel);
System.out.println("Properly initialized map with:");
System.out.println("  - Expected size: " + expectedSize);
System.out.println("  - Load factor: " + loadFactor);
System.out.println("  - Concurrency level: " + concurrencyLevel);
}
// 2. Atomic operations using compute methods
public void atomicOperations() {
ConcurrentHashMap<String, AtomicInteger> counterMap = new ConcurrentHashMap<>();
// Thread-safe counter increment
String key = "request.count";
counterMap.compute(key, (k, current) -> {
if (current == null) {
return new AtomicInteger(1);
}
current.incrementAndGet();
return current;
});
// More concise using computeIfAbsent and then update
AtomicInteger counter = counterMap.computeIfAbsent(key, k -> new AtomicInteger(0));
counter.incrementAndGet();
System.out.println("Counter value: " + counterMap.get(key).get());
}
// 3. Safe compound operations
public void safeCompoundOperations() {
ConcurrentHashMap<String, List<String>> userPreferences = new ConcurrentHashMap<>();
String userId = "user123";
// Safe way to update a collection value
userPreferences.compute(userId, (k, currentList) -> {
List<String> list = (currentList == null) ? new ArrayList<>() : currentList;
list.add("preference-" + System.currentTimeMillis());
return list;
});
// For better performance with frequent updates
List<String> preferences = 
userPreferences.computeIfAbsent(userId, k -> Collections.synchronizedList(new ArrayList<>()));
preferences.add("another-preference");
System.out.println("User preferences: " + userPreferences.get(userId));
}
}
public static class CommonPitfalls {
// 1. Non-atomic check-then-act
public void checkThenActProblem() {
ConcurrentHashMap<String, String> cache = new ConcurrentHashMap<>();
String key = "expensive.computation";
// ❌ WRONG - Race condition between containsKey and put
if (!cache.containsKey(key)) {
// Another thread might put here
String value = computeExpensiveValue();
cache.put(key, value); // Might overwrite another thread's value
}
// ✅ CORRECT - Use putIfAbsent or computeIfAbsent
cache.computeIfAbsent(key, k -> computeExpensiveValue());
}
// 2. Assuming size() is exact
public void sizeMethodPitfall() {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
// ❌ WRONG - size() might be outdated immediately
if (map.size() > 1000) {
// By the time we get here, size might have changed
System.out.println("Map is large: " + map.size());
}
// ✅ CORRECT - Use for specific use cases only
// size() is useful for monitoring, not for program logic
}
// 3. Iteration and modification
public void iterationPitfall() {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
// ❌ WRONG - ConcurrentModificationException won't occur, but behavior might be unexpected
for (String key : map.keySet()) {
if (key.equals("b")) {
map.remove(key); // Safe, but might not be seen by current iterator
}
}
// ✅ CORRECT - Use iterator.remove() or collect keys to remove
Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Integer> entry = iterator.next();
if (entry.getKey().equals("b")) {
iterator.remove(); // Safe removal during iteration
}
}
}
private String computeExpensiveValue() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
return "computed-value";
}
}
public static class AdvancedPatterns {
// 1. Cache with expiration
public static class ExpiringCache<K, V> {
private final ConcurrentHashMap<K, CacheEntry<V>> cache = new ConcurrentHashMap<>();
private final long defaultTtl;
public ExpiringCache(long defaultTtlMillis) {
this.defaultTtl = defaultTtlMillis;
}
public V get(K key) {
CacheEntry<V> entry = cache.get(key);
if (entry == null) return null;
if (System.currentTimeMillis() > entry.expirationTime) {
cache.remove(key, entry); // Remove only if still the same entry
return null;
}
return entry.value;
}
public void put(K key, V value) {
put(key, value, defaultTtl);
}
public void put(K key, V value, long ttlMillis) {
long expirationTime = System.currentTimeMillis() + ttlMillis;
cache.put(key, new CacheEntry<>(value, expirationTime));
}
// Background cleanup thread
public void startCleanup() {
Thread cleanupThread = new Thread(() -> {
while (!Thread.currentThread().isInterrupted()) {
try {
Thread.sleep(60000); // Cleanup every minute
cleanupExpired();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
});
cleanupThread.setDaemon(true);
cleanupThread.start();
}
private void cleanupExpired() {
long now = System.currentTimeMillis();
cache.entrySet().removeIf(entry -> now > entry.getValue().expirationTime);
}
private static class CacheEntry<V> {
final V value;
final long expirationTime;
CacheEntry(V value, long expirationTime) {
this.value = value;
this.expirationTime = expirationTime;
}
}
}
// 2. Rate limiter using compute
public static class RateLimiter {
private final ConcurrentHashMap<String, RequestInfo> requests = new ConcurrentHashMap<>();
private final int maxRequests;
private final long timeWindowMillis;
public RateLimiter(int maxRequests, long timeWindowMillis) {
this.maxRequests = maxRequests;
this.timeWindowMillis = timeWindowMillis;
}
public boolean allowRequest(String clientId) {
long currentTime = System.currentTimeMillis();
return requests.compute(clientId, (k, existingInfo) -> {
if (existingInfo == null || 
currentTime - existingInfo.windowStart > timeWindowMillis) {
// New time window
return new RequestInfo(1, currentTime);
} else if (existingInfo.count < maxRequests) {
// Within limit
existingInfo.count++;
return existingInfo;
} else {
// Over limit
return existingInfo;
}
}).count <= maxRequests;
}
private static class RequestInfo {
int count;
long windowStart;
RequestInfo(int count, long windowStart) {
this.count = count;
this.windowStart = windowStart;
}
}
}
}
public static void main(String[] args) {
CorrectUsage correctUsage = new CorrectUsage();
correctUsage.properInitialization();
correctUsage.atomicOperations();
correctUsage.safeCompoundOperations();
CommonPitfalls pitfalls = new CommonPitfalls();
pitfalls.checkThenActProblem();
AdvancedPatterns.ExpiringCache<String, String> cache = 
new AdvancedPatterns.ExpiringCache<>(300000); // 5 minutes TTL
cache.put("key1", "value1");
System.out.println("Cache get: " + cache.get("key1"));
AdvancedPatterns.RateLimiter rateLimiter = new AdvancedPatterns.RateLimiter(10, 60000); // 10 requests/minute
System.out.println("Rate limit allowed: " + rateLimiter.allowRequest("client1"));
}
}

Conclusion

Key Design Takeaways:

1. Fine-Grained Locking: Synchronizes on individual buckets rather than the entire map
2. CAS Operations: Uses compare-and-swap for lock-free reads and some writes
3. Treeification: Converts long linked lists to balanced trees for O(log n) performance
4. Progressive Resizing: Allows concurrent reads and some writes during resizing
5. Distributed Counting: Uses CounterCell[] to avoid contention on size counter

Performance Characteristics:

When to Use ConcurrentHashMap:

• ✅ High-concurrency read-heavy workloads
• ✅ Frequent updates with moderate contention
• ✅ Need for weakly consistent iteration
• ✅ Atomic compute operations required

When to Consider Alternatives:

• ❌ Extremely high write contention (consider ConcurrentHashMap with higher concurrency level)
• ❌ Need for strong consistency in iteration (use synchronized Map)
• ❌ Very small maps (synchronized HashMap might be sufficient)

ConcurrentHashMap's sophisticated internal design makes it the go-to choice for high-performance concurrent mapping in Java, balancing thread safety with exceptional performance through its innovative use of fine-grained locking, CAS operations, and adaptive data structures.