fail-fast vs fail-safe Iterators in Java

What is a Fail-Fast Iterator?

A Fail-Fast Iterator is an iterator that immediately fails (throws an exception) if it detects any structural modification of the collection after the iterator was created.

Key Characteristics

Fail-Fast Example with ArrayList

import java.util.*;

public class FailFastExample {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Amit");
        names.add("Sneha");
        names.add("Rahul");

        Iterator<String> iterator = names.iterator();
        while (iterator.hasNext()) {
            String name = iterator.next();
            if (name.equals("Sneha")) {
                names.remove(name); // Modifying the collection during iteration
            }
        }
    }
}

Output:

Exception in thread "main" java.util.ConcurrentModificationException

⚠️ Why the Error?

• The iterator detects that the list was structurally modified (remove() was called).
• Java’s fail-fast mechanism throws ConcurrentModificationException to prevent unpredictable behavior.

What is a Fail-Safe Iterator?

A Fail-Safe Iterator is an iterator that does not throw an exception if the collection is modified during iteration. Instead, it iterates over a copy of the collection.

Key Characteristics

Fail-Safe Example with ConcurrentHashMap

import java.util.concurrent.ConcurrentHashMap;

public class FailSafeExample {
    public static void main(String[] args) {
        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
        map.put(1, "Amit");
        map.put(2, "Sneha");
        map.put(3, "Rahul");

        for (Integer key : map.keySet()) {
            if (key == 2) {
                map.put(4, "Kiran"); // Modifying the map during iteration
            }
            System.out.println(key + " => " + map.get(key));
        }
    }
}

Output:

1 => Amit
2 => Sneha
3 => Rahul

• No exception is thrown, even though the map was modified during iteration.
• However, the new entry (4 => Kiran) may or may not be reflected in the current loop, depending on timing.

📊 Comparison Table: Fail-Fast vs Fail-Safe Iterators

How Do Fail-Fast Iterators Work Internally?

Fail-Fast iterators rely on an internal field called modCount in collection classes like ArrayList and HashMap.

• modCount keeps track of the number of structural modifications.
• When you call iterator.next(), it checks if the modCount value has changed since the iterator was created.
• If it has, the iterator assumes that the collection has been modified outside of itself, and throws a ConcurrentModificationException.

How Do Fail-Safe Iterators Work Internally?

Fail-Safe iterators either:

1. Clone the collection and iterate over the copy.
    Example: CopyOnWriteArrayList, CopyOnWriteArraySet
2. Use a lock-free data structure with internal concurrency control.
    Example: ConcurrentHashMap

This is why fail-safe iterators are safe from concurrent modification, but also slower and more memory-intensive.

✅ When to Use Fail-Fast vs Fail-Safe

Use Fail-Fast 

When: 

1. You are working in a single-threaded environment. 
2. You want to detect bugs early if someone modifies a collection during iteration. 
3. Performance is more critical than safety. 

Use Fail-Safe 

When: 

1. You are working in a multi-threaded application. 
2. You expect that the collection might change during iteration. 
3. You need thread-safe iterators and are okay with slightly slower performance.

🚫 Best Practices to Avoid ConcurrentModificationException

• Don’t modify collections directly while iterating.
• Use Iterator.remove() method instead of Collection.remove().

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String name = iterator.next();
    if (name.equals("John")) {
        iterator.remove(); // Safe way to remove
    }
}

• Use fail-safe collections like ConcurrentHashMap or CopyOnWriteArrayList in multi-threaded scenarios.
• Avoid using the same collection instance across threads without proper synchronization.

🧾 Summary

✅ Final Thoughts

Understanding the difference between Fail-Fast and Fail-Safe iterators in Java is critical, especially when working with concurrent or multi-threaded environments.

• Use fail-fast iterators for high performance and when you can guarantee that the collection won’t be modified during iteration.
• Use fail-safe iterators when safety is a priority and you expect changes to the collection while iterating.

By choosing the right type of iterator and following best practices, you can avoid tricky bugs and build robust Java applications.