Fail- fast iterator and Fail-safe iterator

Java iterator provides us with interface to parse the items of the underlying collection.
When we are using the iterator the underlying collection should not be modified.
If this treaty is not honoured and it is possible in a multi-threaded environment, then we get a ConcurrentModificationException.

What is the difference between Fail- fast iterator and Fail-safe iterator ?

Fail fast : it may fail ... and the failure condition is checked aggressively so that the failure condition is detected before damage can be done.

 This behaviour is not guaranteed.
 Detecting modification in the collection and parsing the collection is not done synchronously.
 Modification on the collection may go unnoticed under certain circumstances.
 So while programming, this behaviour should not be banked upon. Example for fail fast iterators are ArrayList, Vector, HashSet.

 fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis.

fail safe : it won't fail.
 iterator doesn't throw any Exception if Collection is modified structurally while one thread is Iterating over it because they work on clone of Collection instead of original collection and that’s why they are called as fail-safe iterator.
Iterator of CopyOnWriteArrayList is an example of fail-safe Iterator also iterator written by ConcurrentHashMap keySet is also fail-safe iterator and never throw ConcurrentModificationException in Java.

 Even if the underlying collection is modified, it does not fail by throwing ConcurrentModificationException.
 When an iterator is created, either it is directly created on the collection, or created on a clone of that collection. One example which supports failsafe iterator is ConcurrentHashMap.


 ConcurrentModificationException : Fail Fast and Fail Safe iterators
The ConcurrentModificationException is thrown if the Collection is modified while Iterating over the data structure.
We know that the collection represents a set of objects for which it manages an internal data structure (i.e. an Object array). Now when we want to iterate over the collection of objects. We have two approaches:

1. Fail Fast : In this case the iterator refers the internal data structure directly (i.e. object array) reading the objects. Here it considers the underlying data structure (i.e. the object[]) is not modified while iterating through the collection. To do this it manages an internal flag which is set on any modification to the data structure (like add / remove), and every time we call the iterator to get the next element it checks the flag. If it finds the data was modified after this iterator was created, it throws exception; ConcurrentModificationException.

2. Fail Safe : In this case the iterator will make a copy of the internal data structure and iterates over the copied data structure. Thus any modifications done to the internal data structure will not effect the iterator. In this case we dont find ConcurrentModificationException. But in this approach we can find the following two issues:
a. The overhead of copying the data structure (time and memory)
b. The fail safe iterator doesnt guarantees the data being read is the data currently in the data structure with the created collection.
The java.util.Iterator is implemented using fail fast approach. That means using the Iterator (i.e. the iterator() method of List) will not result in creating a copy of internal object array but will reset the flag.
The java.util.Enumeration is a fail safe approach implemented. That means using the Enumeration (like elements() method of Vector) results to create a copy of internal data structure.

Fail fast or fail safe – which is better?

fail fast is best.


a. Fail-fast throw ConcurrentModificationException while Fail-safe does not.
b. Fail-fast does not clone the original collection list of objects while Fail-safe creates a copy of the original collection list of objects.