关于iterator的快速失败机制

本文主要用最简单的描述来讲解在什么情况下会发生快速失败

首先了解一下Iterator接口

public interface Iterator<E> {
  
    boolean hasNext();
    E next();
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

其中主要有三个方法

1. hasNext（）
   hasNext用于判断是否存在下一项，注意是下一项，也就是说当刚开始遍历的时候，hasNext位置是没有元素的，他判断的是下一项。
   如下图所示，迭代器中有元素1，2，3，刚开始他没有指向任何元素，如果此时运行iterator的remove（）方法，将报错。因为此时还没有元素怎么能进行移除呢？
   
   示例：

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
       List<Integer> list = new ArrayList<>();

       for (int i = 0; i<10;i++){
           list.add(i);
       }
        Iterator<Integer> iterator = list.iterator();
       while (iterator.hasNext()){
           iterator.remove();
       }


    }
}

错误：

2. next（）方法
   这个方法就是返回下一个元素，当调用这个方法后，hasNext就会后移，如果不调用的话，while就是一个死循环了。

3. remove（）方法
   remove会删除上一次next的元素，也就是hasNext指向的元素，这也就是为什么刚开始不能进行remove的原因。

快速失败

fail-fast 机制，即快速失败机制，是java集合(Collection)中的一种错误检测机制。当在迭代集合的过程中该集合在结构上发生改变的时候，就有可能会发生fail-fast，即抛出 ConcurrentModificationException异常。fail-fast机制并不保证在不同步的修改下一定会抛出异常，它只是尽最大努力去抛出，所以这种机制一般仅用于检测bug。

首先说一下Itr类，它是ArrayList的内部类，实现了Iterator接口
他有三个重要的属性

int cursor;       // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;

• cursor是指集合遍历过程中的即将遍历的元素的索引，
• lastRet是cursor -1，默认为-1，即不存在上一个时，为-1，它主要用于记录刚刚遍历过的元素的索引。
• expectedModCount这个就是fail-fast判断的关键变量了，它初始值就为ArrayList中的modCount。（快速失败的关键）

modCount是抽象类AbstractList中的变量，默认为0，而ArrayList 继承了AbstractList ，所以也有这个变量，modCount用于记录集合操作过程中作的修改次数

开始的时候将modCount的值赋给了expectedModCount ，如果你调用了集合的remove（）方法（注意不是迭代器的remove），这个时候ModeCount将会进行改变。

在每次调用Next的时候都会比较两个值的大小，如果不相等，就会触发快速失败。

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

例如：

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
       List<Integer> list = new ArrayList<>();

       for (int i = 0; i<10;i++){
           list.add(i);
       }
        Iterator<Integer> iterator = list.iterator();
       while (iterator.hasNext()){
           System.out.println(iterator.next());
           list.remove(8);
       }


    }
}

结果：

当输出第一个元素后，第二次会进行判断，此时就触发了快速失败。

调用iterator的remove方法是不会触发快速失败的。（注意不能一开始就调用，否则就会触发上面讲过的异常）

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
       List<Integer> list = new ArrayList<>();

       for (int i = 0; i<10;i++){
           list.add(i);
       }

        System.out.println("迭代前：");
       list.forEach(System.out::print);
        Iterator<Integer> iterator = list.iterator();
       while (iterator.hasNext()){
           iterator.next();
           iterator.remove();
       }

        System.out.println();
        System.out.println("迭代后：");
        list.forEach(System.out::print);

    }
}

结果：