java ArrayList 迭代器快速失败源码分析

先来看一个例子：

     @Test
     void test2() {
         ArrayList<String> list = new ArrayList<String>();
         list.add("a");
         list.add("b");
         list.add("c");
         list.add("d");
         list.add("e");
 //        list.add("f");
         Iterator<String> iterator = list.iterator();
         while(iterator.hasNext()){
             String str = (String) iterator.next();
             if(str.equals("d")){
                 list.remove(str);
 //                iterator.remove();
             }else{
                 System.out.println(str);
             }
         }
     }

Console:

 a
 b
 c

这段代码运行不会报错，但输出不符合我们的预期。我们预期应该是输出：a,b,c,e

如果我们换成删除c，则会报 java.util.ConcurrentModificationException 异常

为什么会出现这个问题呢？

我们跟踪到源码可以发现，ArrayList 类有一个成员变量 modCount 继承自 AbstractList 类

AbstractList 类：

 protected transient int modCount = 0;

transient 关键字修饰，表明变量不必参与序列化。
这个变量的作用是记录list 结构被修改的次数
在add 和 remove 方法里面都能看到它的身影
add方法：

     //add方法会调用此方法
     private void ensureExplicitCapacity(int minCapacity) {
         modCount++;

         // overflow-conscious code
         if (minCapacity - elementData.length > 0)
             grow(minCapacity);
     }

remove(int)方法：

     public E remove(int index) {
         rangeCheck(index);

         modCount++;
         E oldValue = elementData(index);

         int numMoved = size - index - 1;
         if (numMoved > 0)
             System.arraycopy(elementData, index+1, elementData, index,
                              numMoved);
         elementData[--size] = null; // clear to let GC do its work

         return oldValue;
     }

remove(Object) 方法:

     public boolean remove(Object o) {
         if (o == null) {
             for (int index = 0; index < size; index++)
                 if (elementData[index] == null) {
                     fastRemove(index);
                     return true;
                 }
         } else {
             for (int index = 0; index < size; index++)
                 if (o.equals(elementData[index])) {
                     fastRemove(index);
                     return true;
                 }
         }
         return false;
     }

而ArrayList的迭代器是ArrayList的一个内部类：

     public Iterator<E> iterator() {
         return new Itr();
     }

Itr 源码：

     private class Itr implements Iterator<E> {
         int cursor;       // index of next element to return
         int lastRet = -1; // index of last element returned; -1 if no such
         int expectedModCount = modCount;

         Itr() {}

         public boolean hasNext() {
             return cursor != size;
         }

         @SuppressWarnings("unchecked")
         public E next() {
             checkForComodification();
             int i = cursor;
             if (i >= size)
                 throw new NoSuchElementException();
             Object[] elementData = ArrayList.this.elementData;
             if (i >= elementData.length)
                 throw new ConcurrentModificationException();
             cursor = i + 1;
             return (E) elementData[lastRet = i];
         }

         public void remove() {
             if (lastRet < 0)
                 throw new IllegalStateException();
             checkForComodification();

             try {
                 ArrayList.this.remove(lastRet);
                 cursor = lastRet;
                 lastRet = -1;
                 expectedModCount = modCount;
             } catch (IndexOutOfBoundsException ex) {
                 throw new ConcurrentModificationException();
             }
         }

         @Override
         @SuppressWarnings("unchecked")
         public void forEachRemaining(Consumer<? super E> consumer) {
             Objects.requireNonNull(consumer);
             final int size = ArrayList.this.size;
             int i = cursor;
             if (i >= size) {
                 return;
             }
             final Object[] elementData = ArrayList.this.elementData;
             if (i >= elementData.length) {
                 throw new ConcurrentModificationException();
             }
             while (i != size && modCount == expectedModCount) {
                 consumer.accept((E) elementData[i++]);
             }
             // update once at end of iteration to reduce heap write traffic
             cursor = i;
             lastRet = i - 1;
             checkForComodification();
         }

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

可以看到迭代器有一个内部变量 expectedModCount  是拷贝的 modCount

next() 会检查modCount 是否改变，若改变则抛出 ConcurrentModificationException 异常

所以文章开头的第一种情况就可以解释了，之所以删除d’没有报错是因为，d是倒数第二个元素，删除之后，游标 cursor == size

在hasNext方法执行的时候就已经返回了false，没有执行next()方法

而改成c以后，next()会被执行，从而检查出modCount 被修改，抛出异常。

而调用迭代器的remove 方法就不会出现这种情况，因为它更新了expectedModCount，使之与 modCount 保持一致

迭代器的remove方法：

 public void remove() {
             if (lastRet < 0)
                 throw new IllegalStateException();
             checkForComodification();

             try {
                 ArrayList.this.remove(lastRet);
                 cursor = lastRet;
                 lastRet = -1;
　　　　　　　　　　　　//更新expectedModCount
                 expectedModCount = modCount;
             } catch (IndexOutOfBoundsException ex) {
                 throw new ConcurrentModificationException();
             }
         }

快速失败是为了保证数据的安全性，防止并发修改出现的错误。HashMap 等等非线程安全的集合也有同样的机制。

并发情况下应该使用线程安全的集合工具，例如CopyOnWriteArrayList，ConcurrentHashMap 等