双端队列删除未引发ConcurrentModificationException

Question

The Deque class' Javadoc says:

The iterators returned by this class's iterator method are fail-fast: If the deque is modified at any time after the iterator is created, in any way except through the iterator's own remove method, the iterator will generally throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.

However, the below program behaves differently:

[EDIT]: I am getting error while pasting the whole code "An error occurred submitting the edit". Whew! C'mon SO.

// create an empty array deque with an initial capacity
Deque deque = new ArrayDeque(8);

// use add() method to add elements in the deque
deque.add(15);
deque.add(22);
deque.add(25);
deque.add(20);

System.out.println("printing elements using iterator:");
for(Iterator itr = deque.iterator();itr.hasNext();)  {
    System.out.println(itr.next());
    deque.remove(); //deque is modifed after the iterator is created
}

I expected it to throw ConcurrentModificationException , but it simply prints the following output:

printing elements using iterator:
15
22
25
20   

Any idea why?

Answer 1

It looks like it's because you consume the first element of the iterator before removing it. If you change your code to

for(Iterator itr = deque.iterator();itr.hasNext();)  {
    deque.remove(); 
    System.out.println(itr.next());
}

then you'll see the exception. Your original implementation does indeed contradict the documentation.

However, looking in the implementation of ArrayDeque's iterator implementation, the next() method has this code:

E result = (E) elements[cursor];
// This check doesn't catch all possible comodifications,
// but does catch the ones that corrupt traversal
if (tail != fence || result == null)
    throw new ConcurrentModificationException();

Note the following paragraph in the Deque's Javadoc :

Note that the 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. Therefore, it would be wrong to write a program that depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect bugs.