[Java] Java集合中的fail-fast(快速失败)机制详解

private class ListItr implements ListIterator<E> {
 private Node<E> lastReturned;
 private Node<E> next;
 private int nextIndex;
 private int expectedModCount = modCount;

public E next() {
  checkForComodification();
  if (!hasNext())
  throw new NoSuchElementException();
 
  lastReturned = next;
  next = next.next;
  nextIndex++;
  return lastReturned.item;
 }

final void checkForComodification() {
 if (modCount != expectedModCount)
  throw new ConcurrentModificationException();

// 添加元素到队列最后
public boolean add(E e) {
 // 修改modCount
 ensureCapacity(size + 1); // Increments modCount!!
 elementData[size++] = e;
 return true;
}
 
 
// 添加元素到指定的位置
public void add(int index, E element) {
 if (index > size || index < 0)
  throw new IndexOutOfBoundsException(
  "Index: "+index+", Size: "+size);
 
 // 修改modCount
 ensureCapacity(size+1); // Increments modCount!!
 System.arraycopy(elementData, index, elementData, index + 1,
   size - index);
 elementData[index] = element;
 size++;
}
 
// 添加集合
public boolean addAll(Collection<? extends E> c) {
 Object[] a = c.toArray();
 int numNew = a.length;
 // 修改modCount
 ensureCapacity(size + numNew); // Increments modCount
 System.arraycopy(a, 0, elementData, size, numNew);
 size += numNew;
 return numNew != 0;
}
 
 
// 删除指定位置的元素
public E remove(int index) {
 RangeCheck(index);
 
 // 修改modCount
 modCount++;
 E oldValue = (E) elementData[index];
 
 int numMoved = size - index - 1;
 if (numMoved > 0)
  System.arraycopy(elementData, index+1, elementData, index, numMoved);
 elementData[--size] = null; // Let gc do its work
 
 return oldValue;
}
 
 
// 快速删除指定位置的元素
private void fastRemove(int index) {
 
 // 修改modCount
 modCount++;
 int numMoved = size - index - 1;
 if (numMoved > 0)
  System.arraycopy(elementData, index+1, elementData, index,
     numMoved);
 elementData[--size] = null; // Let gc do its work
}
 
// 清空集合
public void clear() {
 // 修改modCount
 modCount++;
 
 // Let gc do its work
 for (int i = 0; i < size; i++)
  elementData[i] = null;
 
 size = 0;
}

public class CopyOnWriteArrayList<E>
 implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
 
 ...
 
 // 返回集合对应的迭代器
 public Iterator<E> iterator() {
  return new COWIterator<E>(getArray(), 0);
 }
 
 ...
 
 private static class COWIterator<E> implements ListIterator<E> {
  private final Object[] snapshot;
 
  private int cursor;
 
  private COWIterator(Object[] elements, int initialCursor) {
   cursor = initialCursor;
   // 新建COWIterator时，将集合中的元素保存到一个新的拷贝数组中。
   // 这样，当原始集合的数据改变，拷贝数据中的值也不会变化。
   snapshot = elements;
  }
 
  public boolean hasNext() {
   return cursor < snapshot.length;
  }