Concurrent Collections

Thread-safe collections from java.util.concurrent.

At a Glance

• ConcurrentHashMap — General-purpose thread-safe map. Lock-free reads, per-bucket locking on writes. High throughput under contention. No nulls allowed. Default choice when you need a shared map.
• ConcurrentSkipListMap — Sorted concurrent map (like a thread-safe TreeMap). O(log n) operations via lock-free CAS. Use when you need sorted keys with concurrent access. Higher overhead than ConcurrentHashMap for unsorted workloads.
• ConcurrentSkipListSet — Sorted concurrent set backed by ConcurrentSkipListMap. Use when you need a thread-safe TreeSet.
• ConcurrentHashMap.newKeySet() — Concurrent unordered set backed by ConcurrentHashMap. Use when you need a thread-safe HashSet.
• CopyOnWriteArrayList — Every write copies the entire backing array. Reads are lock-free and fast. Use for listener/observer lists or configs that are read often and rarely modified. Writes are O(n) and expensive at scale.
• CopyOnWriteArraySet — Set backed by CopyOnWriteArrayList. Same tradeoffs: great for small, read-heavy sets. contains() is O(n).
• ConcurrentLinkedQueue — Unbounded lock-free FIFO queue. Use for high-throughput producer-consumer when you don't need blocking. size() is O(n).
• ConcurrentLinkedDeque — Unbounded lock-free double-ended queue. Use when you need both FIFO and LIFO access concurrently.
• ArrayBlockingQueue — Bounded, array-backed blocking queue. put() blocks when full, take() blocks when empty. Single lock means lower throughput than LinkedBlockingQueue, but bounded capacity prevents memory issues.
• LinkedBlockingQueue — Optionally bounded blocking queue with separate put/take locks for higher throughput. Default choice for bounded producer-consumer. Unbounded by default — set a capacity to avoid memory leaks.
• PriorityBlockingQueue — Unbounded blocking queue ordered by priority (heap). Use for priority-based task scheduling. Cannot be bounded — producers never block.
• SynchronousQueue — Zero-capacity direct handoff. put() blocks until another thread calls take(). Used by Executors.newCachedThreadPool(). No buffering — tight coupling between producer and consumer.
• DelayQueue — Unbounded queue where elements become available only after their delay expires. Use for scheduled retries, cache expiration, rate limiting. Elements must implement Delayed.
• LinkedTransferQueue — Unbounded FIFO queue that combines SynchronousQueue semantics (transfer() blocks until consumed) with normal queue buffering. Most flexible blocking queue — use when you sometimes want direct handoff and sometimes want buffering.
• LinkedBlockingDeque — Optionally bounded blocking double-ended queue. Use for work-stealing algorithms where threads take from their own end and steal from the other.

ConcurrentHashMap

The workhorse concurrent map. High throughput under contention.

Key Differences from HashMap

ConcurrentMap<String, Integer> counters = new ConcurrentHashMap<>();

// Atomic increment
counters.merge("hits", 1, Integer::sum);

// Atomic compute
counters.compute("hits", (k, v) -> v == null ? 1 : v + 1);

// putIfAbsent — returns existing value if key present
counters.putIfAbsent("misses", 0);

// Bulk operations (parallel with threshold)
counters.forEach(1000, (k, v) ->
    System.out.println(k + " = " + v));

long total = counters.reduceValues(1000, Integer::sum);

// As a concurrent Set
Set<String> set = ConcurrentHashMap.newKeySet();

ConcurrentSkipListMap & ConcurrentSkipListSet

Concurrent sorted collections. The thread-safe equivalent of TreeMap / TreeSet.

ConcurrentNavigableMap<String, Integer> map = new ConcurrentSkipListMap<>();
map.put("banana", 2);
map.put("apple", 5);
map.put("cherry", 3);

map.firstKey();              // "apple"
map.headMap("cherry");       // {apple=5, banana=2}

NavigableSet<String> set = new ConcurrentSkipListSet<>();
set.add("B");
set.add("A");
set.first();                 // "A"

Copy-on-Write Collections

Best for read-heavy workloads with infrequent writes. Every mutation copies the entire array.

List<EventListener> listeners = new CopyOnWriteArrayList<>();
listeners.add(myListener);

// Safe iteration — iterates over a snapshot
for (EventListener l : listeners) {
    l.onEvent(event);  // no ConcurrentModificationException
}

// Writes are expensive (copies entire array)
listeners.remove(myListener);

Concurrent (Non-Blocking) Queues

Lock-free queues for high-throughput producer-consumer scenarios without blocking.

Queue<Task> tasks = new ConcurrentLinkedQueue<>();

// Producer
tasks.offer(new Task("process-order"));

// Consumer (non-blocking — returns null if empty)
Task t = tasks.poll();

Blocking Queues

Queues that block on put() when full and take() when empty. Core building block for producer-consumer patterns.

BlockingQueue API

// Bounded producer-consumer
BlockingQueue<Task> queue = new ArrayBlockingQueue<>(100);

// Producer thread
queue.put(new Task("job-1"));  // blocks if full

// Consumer thread
Task t = queue.take();          // blocks if empty

// With timeout
Task t2 = queue.poll(5, TimeUnit.SECONDS);

// SynchronousQueue — direct handoff
BlockingQueue<Task> handoff = new SynchronousQueue<>();
// put() blocks until another thread calls take()

// DelayQueue — elements available only after delay expires
DelayQueue<DelayedTask> delayed = new DelayQueue<>();
delayed.put(new DelayedTask("retry", 30, TimeUnit.SECONDS));

LinkedBlockingDeque

A blocking double-ended queue. Useful for work-stealing algorithms.

BlockingDeque<Task> deque = new LinkedBlockingDeque<>(100);

deque.putFirst(highPriority);   // blocks if full
deque.putLast(normalTask);

Task t = deque.takeFirst();     // blocks if empty
Task t2 = deque.takeLast();     // steal from other end

Choosing the Right Collection