(简单易懂)Java的快速失败（fail-fast）与安全失败，源码分析+详细讲解

之前在程序中遇到快速失败的问题，在网上找解释时发现网上的问题总结都比较片面，故打算自己总结一个，也可以供以后参考。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　--宇的季节

首先什么是快速失败？

快速失败是为了提示程序员在多线程的情况下不要用线程不安全的集合（bug）的一种机制。

当然在单线程的情况下有时也会出现ConcurrentModificationException异常，下面我们就根据ArrayList来探索快速失败的内部实现方法。

示例一：

public static void main(String[] args) {

List<String> list = new ArrayList<String>();

//为集合添加100个数

for (int i = 0; i < 100; i++)

list.add(i+"");

//获取集合的迭代器

Iterator<String> iter = list.iterator();

//我们在集合中删除一个数据，注意我们是直接用集合操作而不是迭代器

list.remove("2");

//再使用迭代器获取数据

iter.next();

}

执行结果：

果不其然，报了ConcurrentModificationException的错误。

为什么会报错呢？下面我们就来看看ArrayList的源码（为了方便阅读，把没用的都省略了）

public class ArrayList<E> ,,,,,
 
{
 
....
 
//modCount：集合的修改次数
 
protected transient int modCount = 0;
 
//当出现增删操作时，便会modCount++；
 
public E remove(int index) {
 
        ....
 
        modCount++;
 
        ......
 
    }
 
....
 
//通过此方法获取迭代器
 
public Iterator<E> iterator() {
 
return new Itr();
 
}
 
....
 
//迭代器是ArrayList的一个内部类
 
private class Itr implements Iterator<E> {
 
        ...
 
//每次获取一个迭代器，就新建一个对象，将expectedModCount赋值为modCount
 
        int expectedModCount = modCount;
 
       .....
 
        @SuppressWarnings("unchecked")
 
        public E next() {
 
//检查expectedModCount和modCount是否相等
 
            checkForComodification();
 
            .....
 
        }
 
//这个就是检查的方法
 
final void checkForComodification() {
 
            if (modCount != expectedModCount)
 
                throw new ConcurrentModificationException();
 
        }  
 
.....
 
  }

我们已经了解了ArrayList的大概结构，那么示例一的报错也就不难解释了：

假设创建一个迭代器时modCount=10,那么expectedModCount=10（注意，modCount是ArrayList的参数，而expectedModCount是迭代器的参数，从创建迭代器之后，他们就没联系了）

当执行list.remove("2");操作时，modCount++=11;而此时expectedModCount=10；当我们再执行iter.next()时，很明显两个数不一致，抛出异常。

结论：当我们在获取一个快速失败集合（只要不是concurrent包下的集合都是快速失败的）的迭代器时候，之后在操作迭代器的中间不能对集合本身再进行增删操作，否则会抛异常。

但是，快速失败机制的意义并不在此，上面已经说到了，快速失败是为了警告程序员不能在多线程情况下使用线程不安全的集合。

示例2：

public class test {
    private static List<String> list = new ArrayList<String>();
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++)
        list.add(i+"");
        System.out.println("线程开始了");
        new threadOne().start();
        new threadTwo().start();
    }
//线程1每隔10ms遍历一次
    private static class threadOne extends Thread{
        public void run(){
            Iterator<String> iter = list.iterator();
            while(iter.hasNext()){
                System.out.println("线程1遍历到了："+iter.next());
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
//线程1每隔10ms删除一个
    private static class threadTwo extends Thread{
        public void run(){
            Iterator<String> iter = list.iterator();
            while(iter.hasNext()){
                System.out.println("线程2删除了："+iter.next());
                iter.remove();
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

执行结果：

在示例2中，我们并没有在使用迭代器中间直接对集合进行增删。但是依然报错。

原因就是因为线程的异步性！

这次只看迭代器的remove()操作即可：

可以看到，两个值的改变被分成了两条程序语句，那么就会出现这种情况：

线程1删除时执行到语句1，modCount+1。

由于语句2还没执行，expectedModCount不会改变

这时处理器跳转到线程2执行。

线程2执行next()时，对比modCount和expectedModCount。

发现两值不一致，抛出ConcurrentModificationException

终于把快速失败搞明白了！那么什么是安全失败呢？

这个就简单了，在使用安全失败的迭代器时，会copy一个集合，之后的操作都是对这个copy的“副本”进行操作。

那么就算是多线程，操作的也是创建迭代器时copy的单独的副本。

所以不会造成冲突，ConcurrentModificationException也就不复存在啦~