Java集合框架中关于fail-fast机制的解释

我们在做关于集合面试题的时候，总会碰到关于fail-fast这个词语，关于这个词语大家觉得很陌生，而我的这篇将会详细解释这个词语，希望能帮助到大家。
我们从如下几个问题来了解它：
Q1：这个词语是什么意思？是用来干什么的呢？
fail-fast也就是"快速失败机制"，它是Java集合的一种错误检测机制。当多个线程对集合进行结构上的改变的操作时，有可能会产生fail-fast机制。记住是有可能，而不是一定。例如：假设存在两个线程（线程1、线程2），线程1通过Iterator在遍历集合A中的元素，在某个时候线程2修改了集合A的结构（是结构上面的修改，而不是简单的修改集合元素的内容），那么这个时候程序就会抛出 ConcurrentModificationException 异常，从而产生fail-fast机制。
Q2:在哪里会碰到它呢？
例如，1.ArrayList:
注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误的做法：迭代器的快速失败行为应该仅用于检测 bug。
2.HashMap中：
注意，迭代器的快速失败行为不能得到保证，一般来说，存在非同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的做法是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。
接下来我们将从代码上来了解它：
1.示例

package com.test2.theway;

import java.util.ArrayList;
import java.util.Iterator;

public class FailFastTest extends Thread{
    //我们定义一个ArrayList
    private static ArrayList<Integer> list=new ArrayList<Integer>();

    //写一个线程类用来迭代list
    private static class ThreadOne extends Thread{
        @Override
        public void run() {
            Iterator<Integer> iterator=list.iterator();
            while (iterator.hasNext()){
                int i=iterator.next();
                System.out.println("ThreadOne 遍历:" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
    //写一个线程类 我们选择一个时机来修改list
    private static class ThreadTwo extends Thread{
        @Override
        public void run() {
            int i=0;
            while(i<5){
                System.out.println("ThreadTwo run：" + i);
                if(i==3){
                    list.remove(i);
                }
                i++;
            }
        }
    }
    public static void main(String[] args) {
        //向list里添加元素
        for(int i=0;i<10;i++){
            list.add(i);
        }
        new ThreadOne().start();
        new ThreadTwo().start();
    }
}

运行结果：

ThreadOne 遍历:0
ThreadTwo run：0
ThreadTwo run：1
ThreadTwo run：2
ThreadTwo run：3
ThreadTwo run：4
Exception in thread "Thread-0" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
	at java.util.ArrayList$Itr.next(ArrayList.java:851)
	at com.test2.theway.FailFastTest$ThreadOne.run(FailFastTest.java:16)

Process finished with exit code 0

2.为什么出现如此原因呢？

通过上面的示例和讲解，我初步知道fail-fast产生的原因就在于程序在对 collection 进行迭代时，某个线程对该 collection 在结构上对其做了修改，这时迭代器就会抛出 ConcurrentModificationException 异常信息，从而产生 fail-fast。
要了解fail-fast机制，我们首先要对ConcurrentModificationException 异常有所了解。当方法检测到对象的并发修改，但不允许这种修改时就抛出该异常。同时需要注意的是，该异常不会始终指出对象已经由不同线程并发修改，如果单线程违反了规则，同样也有可能会抛出改异常。
迭代器的快速失败行为无法得到保证，它不能保证一定会出现该错误，但是快速失败操作会尽最大努力抛出ConcurrentModificationException异常，所以因此，为提高此类操作的正确性而编写一个依赖于此异常的程序是错误的做法，正确做法是：ConcurrentModificationException 应该仅用于检测 bug。
3.我们可以自己去看下迭代器的源代码就能知晓其中原有。这里我就直接和大家说结论了。

迭代器在调用next()、remove()方法时都是调用checkForComodification()方法，该方法主要就是检测modCount == expectedModCount ? 若不等则抛出ConcurrentModificationException 异常，从而产生fail-fast机制。
ArrayList中无论add、remove、clear方法只要是涉及了改变ArrayList元素的个数的方法都会导致modCount的改变。
有两个线程（线程A，线程B），其中线程A负责遍历list、线程B修改list。线程A在遍历list过程的某个时候（此时expectedModCount = modCount=N），线程启动，同时线程B增加一个元素，这是modCount的值发生改变（modCount + 1 = N + 1）。线程A继续遍历执行next方法时，通告checkForComodification方法发现expectedModCount = N ，而modCount = N + 1，两者不等，这时就抛出ConcurrentModificationException 异常，从而产生fail-fast机制。
4.那在怎么解决这个问题呢？

方案一：在遍历过程中所有涉及到改变modCount值得地方全部加上synchronized或者直接使用Collections.synchronizedList，这样就可以解决。但是不推荐，因为增删造成的同步锁可能会阻塞遍历操作。
方案二：使用CopyOnWriteArrayList来替换ArrayList。推荐使用该方案。
CopyOnWriteArrayList为何物？ArrayList 的一个线程安全的变体，其中所有可变操作（add、set 等等）都是通过对底层数组进行一次新的复制来实现的。 该类产生的开销比较大，但是在两种情况下，它非常适合使用。1：在不能或不想进行同步遍历，但又需要从并发线程中排除冲突时。2：当遍历操作的数量大大超过可变操作的数量时。遇到这两种情况使用CopyOnWriteArrayList来替代ArrayList再适合不过了。 （就不用代码作为演示了）