As Java developers, we often rely on collections like ArrayList and HashMap in our day-to-day coding. These collections are incredibly convenient, but there’s a subtle trap many intermediate developers encounter: concurrent access to non-thread-safe collections.

"If I access a non-thread-safe collection concurrently, Java will always throw a ConcurrentModificationException (CME)."

This isn’t true—and understanding why is a mark of a more senior developer.

The Reality

ConcurrentModificationException is not a catch-all for concurrency issues in collections. It is a fail-fast mechanism designed to detect some, but not all, unsafe modifications during iteration.

Fail-fast iterators are a convenience, not a safety net. Here’s what that means:

1. Iterating while modifying

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
for (Integer i : list) {
    list.add(4); // Might throw ConcurrentModificationException
}

This will likely throw CME because the iterator detects the modification.

2. Concurrent writes without iteration

List<Integer> list = new ArrayList<>();
Thread t1 = () -> list.add(1);
Thread t2 = () -> list.add(2);

t1.start();
t2.start();

Here, no iteration is happening, so no CME occurs, but the list may end up in a corrupted state or have lost updates. The JVM gives no warning, which can lead to subtle, hard-to-diagnose bugs.

Key Takewaways

• CME is best-effort detection, not a guarantee.

• Non-thread-safe collections are vulnerable to silent corruption, lost updates, and unpredictable behavior under concurrency.

• To safely handle concurrent access, use:

  • Collections.synchronizedList(...) or Collections.synchronizedMap(...)
  • Concurrent collections like ConcurrentHashMap, CopyOnWriteArrayList, or ConcurrentLinkedQueue

Why This Matters

Understanding the difference between fail-fast exceptions and real concurrency safety is a key step toward writing robust, maintainable Java code. Senior developers not only write code that works—they anticipate subtle failure modes and choose the right tools to prevent them.

Pro Tip: Don’t rely on ConcurrentModificationException to tell you your code is thread-safe. Treat it as a helpful signal, not a safety net.

---
title: Not All Java Concurrency Bugs Throw ConcurrentModificationException
description: Understanding why ConcurrentModificationException isn’t a safety net and how concurrent access can silently break Java collections
date: 2025-11-07
keywords: [java,concurrency]
---