Difference Between Fail-Fast and Fail-Safe Iterators in Java

Introduction

Iteration is a common operation performed on Java collections, and Java provides different types of iterators to traverse these collections. However, not all iterators behave the same way when the underlying collection is modified while iteration is in progress. Java offers two types of iterators in this context: Fail-Fast and Fail-Safe iterators.

In this article, we will explore the key differences between these iterators, their working mechanisms, examples, and when to use them.

What is a Fail-Fast Iterator?

Fail-Fast iterators operate directly on the underlying collection and fail immediately if they detect structural modifications during iteration. These modifications include adding, removing, or updating elements in the collection while an iteration is in progress.

Characteristics of Fail-Fast Iterators:

Throw ConcurrentModificationException if the collection is structurally modified.
They do not allow modification during iteration (except via the iterator's own remove() method).
They provide fast failure to prevent unpredictable behavior.

Example of Fail-Fast Iterator:

import java.util.ArrayList;
import java.util.Iterator;

public class FailFastExample {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
            // Modifying the list while iterating
            list.add("D"); // Throws ConcurrentModificationException
        }
    }
}

Output:

A
Exception in thread "main" java.util.ConcurrentModificationException

What is a Fail-Safe Iterator?

Fail-Safe iterators work on a copy of the original collection, which ensures that modifications in the original collection do not affect the iteration. This prevents ConcurrentModificationException from occurring.

Characteristics of Fail-Safe Iterators:

Work on a cloned copy of the collection instead of the original.
Do not throw ConcurrentModificationException.
Allow modifications to the original collection while iteration is in progress.
May not reflect changes made to the original collection.

Example of Fail-Safe Iterator:

import java.util.concurrent.CopyOnWriteArrayList;
import java.util.Iterator;

public class FailSafeExample {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
            list.add("D"); // No exception thrown
        }
    }
}

Output:

A
B
C

(Note: The newly added elements are not reflected during the iteration.)

Key Differences Between Fail-Fast and Fail-Safe Iterators

Feature	Fail-Fast Iterator	Fail-Safe Iterator
Collection Type	Works on the original collection	Works on a copy of the collection
Modification During Iteration	Throws `ConcurrentModificationException`	No exception, allows modification
Data Consistency	Ensures consistency by failing fast	May not reflect real-time changes
Performance Impact	Fast but prone to exceptions	Extra memory required for copying
Examples	`ArrayList`, `HashSet`, `HashMap` (normal iterators)	`CopyOnWriteArrayList`, `ConcurrentHashMap`

When to Use Fail-Fast vs. Fail-Safe Iterators

Use Fail-Fast iterators when you need strong consistency and cannot tolerate concurrent modifications.
Use Fail-Safe iterators when performance is critical, and you need to allow modifications during iteration without affecting iteration progress.

Conclusion

Fail-Fast and Fail-Safe iterators serve different purposes in Java collections. While Fail-Fast iterators prevent concurrency issues by throwing exceptions upon modification, Fail-Safe iterators allow modifications but may not reflect real-time changes. Choosing the right iterator depends on the application’s requirements regarding consistency, performance, and thread safety.

By understanding these differences, developers can avoid unexpected runtime exceptions and design more robust and efficient Java applications.