Fail-Fast Behavior

A fail-fast iterator throws a ConcurrentModificationException if the collection is structurally modified (e.g., adding, removing, or modifying elements) after the iterator is created.

When Fail-Fast Issues Occur:

1. Structural Modification During Iteration:
   • If a collection is modified while an iterator is actively iterating through it, the iterator detects this modification and throws a ConcurrentModificationException.
2. Single Thread:
   • Even in a single-threaded environment, modifying a collection directly while iterating over it leads to a fail-fast issue.

List<String> list = new ArrayList<>(List.of("A", "B", "C"));
for (String s : list) {
   if (s.equals("B")) {
       list.remove(s); // Structural modification
   }
}
// Throws ConcurrentModificationException

3.Multi-Threaded Environment:

• In a multi-threaded scenario, one thread iterating over the collection may throw a ConcurrentModificationException if another thread modifies the collection concurrently.

Why Does It Happen?

• ModCount:
  • Most fail-fast iterators rely on a modCount field in the collection. This field tracks structural modifications.
  • When an iterator is created, it captures the current modCount.
  • If the modCount changes during iteration, the iterator detects the discrepancy and throws the exception.

To overcome fail-fast behavior in Java collections, you can use several approaches based on the specific requirements of your application. These solutions focus on avoiding ConcurrentModificationException while iterating over collections that do not inherently support concurrent modifications.

1. Use Iterator's Modification Methods

The Iterator interface provides safe methods like remove() to modify the collection while iterating.

Example:

List<String> list = new ArrayList<>(List.of("A", "B", "C", "D"));
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
   String value = iterator.next();
   if (value.equals("B")) {
       iterator.remove(); // Safe modification
   }
}
System.out.println(list); // Output: [A, C, D]

Why It Works:

• The iterator's remove() method ensures that structural changes to the collection are reflected in the iterator, preventing the modCount mismatch.

2. Use Concurrent Collections

Replace the collection with a fail-safe concurrent collection, such as:

• CopyOnWriteArrayList for lists.
• ConcurrentHashMap for maps.

Example (Using CopyOnWriteArrayList):

List<String> list = new CopyOnWriteArrayList<>(List.of("A", "B", "C", "D"));
for (String value : list) {
   if (value.equals("B")) {
       list.remove(value); // No exception
   }
}
System.out.println(list); // Output: [A, C, D]

Why It Works:

• These collections use a snapshot or lock-free mechanism for iteration, avoiding ConcurrentModificationException.

3. Collect and Modify After Iteration

Collect items to be removed or modified in a separate list, and apply the changes after the iteration completes.

Example:

List<String> list = new ArrayList<>(List.of("A", "B", "C", "D"));
List<String> toRemove = new ArrayList<>();
for (String value : list) {
   if (value.equals("B")) {
       toRemove.add(value); // Collect items to remove
   }
}
list.removeAll(toRemove); // Apply changes after iteration
System.out.println(list); // Output: [A, C, D]

Why It Works:

• The original list is not structurally modified during the iteration.

4. Use Explicit Synchronization

For multi-threaded environments, synchronize the collection or the block of code that modifies it.

Example:

List<String> list = Collections.synchronizedList(new ArrayList<>(List.of("A", "B", "C", "D")));
synchronized (list) {
   Iterator<String> iterator = list.iterator();
   while (iterator.hasNext()) {
       String value = iterator.next();
       if (value.equals("B")) {
           iterator.remove(); // Safe modification
       }
   }
}
System.out.println(list); // Output: [A, C, D]

Why It Works:

• Synchronization ensures thread-safe access to the collection, avoiding concurrent modifications.

5. Use Streams for Filtering

Streams in Java 8+ provide a functional approach to filter collections, avoiding manual iteration and modification.

Example:

List<String> list = new ArrayList<>(List.of("A", "B", "C", "D"));
list = list.stream()
          .filter(value -> !value.equals("B")) // Keep everything except "B"
          .toList(); // Returns a new list
System.out.println(list); // Output: [A, C, D]

6. Avoid Modifications During Iteration

Restructure your logic to avoid modifying the collection directly during iteration. For instance, create a copy of the collection, iterate over the copy, and modify the original.

Example:

List<String> list = new ArrayList<>(List.of("A", "B", "C", "D"));
for (String value : new ArrayList<>(list)) { // Iterate over a copy
   if (value.equals("B")) {
       list.remove(value); // Modify original list
   }
}
System.out.println(list); // Output: [A, C, D]

Why It Works:

• The iteration happens on a copy, so the original collection can be modified safely.

Comparison of Solutions

Fail-Safe Behavior

A fail-safe iterator does not throw a ConcurrentModificationException if the collection is structurally modified during iteration. Instead, it operates on a snapshot of the collection, ensuring safe iteration.

When Fail-Safe Behavior Works:

1. Concurrent Collections:
   • Fail-safe behavior is implemented in concurrent collections like CopyOnWriteArrayList or ConcurrentHashMap.
   • These collections create a snapshot or copy of the data for iteration, avoiding issues caused by concurrent modifications.
   • Example:

List<String> list = new CopyOnWriteArrayList<>(List.of("A", "B", "C"));
for (String s : list) {
   if (s.equals("B")) {
       list.remove(s); // No exception
   }
}
System.out.println(list); // [A, C]
 

Snapshot Iteration:

• The iterator works on the original snapshot, so changes to the collection do not affect the ongoing iteration.

Limitations of Fail-Safe:

• Fail-safe iterators may not reflect the latest changes in the collection during iteration.
• They can be less memory-efficient due to the creation of snapshots.

Avoiding Fail-Fast Issues

1. Use Concurrent Collections:
   • Replace fail-fast collections with concurrent alternatives like ConcurrentHashMap or CopyOnWriteArrayList.
2. Iterate Safely:
   • Use an explicit iterator and modify the collection using the iterator's methods.
   • Example:

List<String> list = new ArrayList<>(List.of("A", "B", "C"));
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
   String s = iterator.next();
   if (s.equals("B")) {
       iterator.remove(); // Safe removal
   }
}

3.  Avoid Modifications During Iteration:

• If possible, collect the items to be removed in a separate list and modify the collection after the iteration.

4. Synchronization:

• In multi-threaded scenarios, synchronize the collection explicitly to avoid concurrent modifications.

How to Handle This in Sets?

1. Use Iterator’s remove() Method

Set<String> set = new HashSet<>();
set.add("A");
set.add("B");
set.add("C");

Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
   String value = iterator.next();
   if (value.equals("B")) {
       iterator.remove(); // Safe way to remove during iteration
   }
}
System.out.println(set); // Output: [A, C]


2. Use Concurrent Collections

Replace HashSet with CopyOnWriteArraySet or other fail-safe collections.

import java.util.concurrent.CopyOnWriteArraySet;

public class SafeSetExample {
   public static void main(String[] args) {
       CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<>();
       set.add("A");
       set.add("B");
       set.add("C");

       for (String value : set) {
           if (value.equals("B")) {
               set.remove(value); // No exception
           }
       }
       System.out.println(set); // Output: [A, C]
   }
}

3. Collect and Modify After Iteration
Set<String> set = new HashSet<>();
set.add("A");
set.add("B");
set.add("C");

Set<String> toRemove = new HashSet<>();
for (String value : set) {
   if (value.equals("B")) {
       toRemove.add(value); // Collect items to remove
   }
}
set.removeAll(toRemove); // Modify after iteration
System.out.println(set); // Output: [A, C]
 

Key Differences Between Fail-Fast and Fail-Safe

Best Practices

• Use Iterator’s remove() for single-threaded scenarios.
• Use fail-safe collections (e.g., CopyOnWriteArraySet) for multi-threaded scenarios.
• Avoid modifying the collection directly during iteration—use intermediate lists or sets to track changes.

Thank You for Your Support! 🙏

Your encouragement keeps us going!

If you find value in our content, please consider supporting us.

💡 Even a small contribution can make a big difference in helping us build better educational resources.

Donate Now