Back to Concurrent Collections

Technical Explanation of Concurrent Collections

1. ConcurrentHashMap

Technical Explanation

  • Mechanism: Thread-safe hash table implementation
  • Concurrency Level: Segment-based locking
  • Key Features:
    • Multiple threads can read simultaneously
    • Limited locking during writes
    • No full collection locking
  • Performance: High concurrent read/write performance
ConcurrentHashMap Segment-Based Locking High Concurrent Performance 

// ConcurrentHashMap usage and thread-safe operations
ConcurrentHashMap map = new ConcurrentHashMap<>();

// Atomic put if absent
map.putIfAbsent("key", 42);

// Atomic compute operations
map.compute("key", (k, v) -> (v == null) ? 1 : v + 1);

// Thread-safe iteration
map.forEach((key, value) -> {
    System.out.println(key + ": " + value);
});

// Atomic get or default
int value = map.getOrDefault("nonexistent", 0);

2. CopyOnWriteArrayList

Technical Explanation

  • Mechanism: Copy-on-write thread-safe list
  • Concurrency Strategy:
    • Create a copy of underlying array for modifications
    • Immutable snapshots during iterations
  • Performance Characteristics:
    • Optimized for read-heavy scenarios
    • Expensive write operations
    • Consistency over performance
CopyOnWriteArrayList Immutable Snapshots Copy-on-Write Mechanism 

// CopyOnWriteArrayList thread-safe operations
CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();

// Thread-safe addition
list.add("First Item");

// Safe iteration while modifying
for (String item : list) {
    if (item.equals("First Item")) {
        list.remove(item);
        list.add("Modified Item");
    }
}

// Atomic operations
list.addIfAbsent("Unique Item");

3. BlockingQueue

Technical Explanation

  • Mechanism: Thread-safe queue with blocking operations
  • Key Methods:
    • put(): Add element (blocks if full)
    • take(): Remove element (blocks if empty)
    • offer(): Add with timeout
    • poll(): Remove with timeout
  • Use Cases:
    • Producer-consumer scenarios
    • Thread communication
    • Work queue implementations
BlockingQueue Thread Synchronization Producer-Consumer Pattern 

// BlockingQueue thread-safe operations
BlockingQueue queue = new LinkedBlockingQueue<>(10);

// Producer thread
new Thread(() -> {
    try {
        for (int i = 0; i < 100; i++) {
            // Blocks if queue is full
            queue.put(i);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

// Consumer thread
new Thread(() -> {
    try {
        while (true) {
            // Blocks if queue is empty
            Integer item = queue.take();
            processItem(item);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();