Java学习笔记 14 快速失败fail-fast机制

深藏阁楼爱情的钟 2022-06-07 01:27 85阅读 0赞

## **一、快速失败fail-fast是什么？** ##

在JDK的Collection中我们时常会看到类似于这样的话：

例如，ArrayList:注意，迭代器的快速失败行为无法得到保证，
    因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。
    快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。
    因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误的做法：
    迭代器的快速失败行为应该仅用于检测 bug。

“快速失败”也就是fail-fast，它是Java集合的一种错误检测机制。当多个线程对集合进行结构上的改变的操作时，有可能会产生fail-fast机制。记住是有可能，而不是一定。例如：假设存在两个线程（线程1、线程2），线程1通过Iterator在遍历集合A中的元素，在某个时候线程2修改了集合A的结构（是结构上面的修改，而不是简单的修改集合元素的内容），那么这个时候程序就会抛出 ConcurrentModificationException 异常，从而产生fail-fast机制。

首先看一个例子:

public class FailFastTest {
        
        private static List<Integer> list = new ArrayList<>();
    
        /**
         * @desc:线程one迭代list
         * @Project:test
         * @file:FailFastTest.java
         * @Authro:chenssy
         * @data:2014年7月26日
         */
        private static class threadOne extends Thread{
        
            public void run() {
                Iterator<Integer> iterator = list.iterator();
                while(iterator.hasNext()){
                    int i = iterator.next();
                    System.out.println("ThreadOne 遍历:" + i);
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        /**
         * @desc:当i == 3时，修改list
         * @Project:test
         * @file:FailFastTest.java
         * @Authro:chenssy
         * @data:2014年7月26日
         */
        private static class threadTwo extends Thread{
        
            public void run(){
                int i = 0 ; 
                while(i < 6){
                    System.out.println("ThreadTwo run：" + i);
                    if(i == 3){
                        list.remove(i);
                    }
                    i++;
                }
            }
        }
    
        public static void main(String[] args) {
            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
    ThreadTwo run：5
    Exception in thread "Thread-0" java.util.ConcurrentModificationException
        at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
        at java.util.ArrayList$Itr.next(Unknown Source)
        at test.ArrayListTest$threadOne.run(ArrayListTest.java:23)

## **二、原因分析** ##

通过上面的示例和讲解，我我们初步可以知道fail-fast产生的原因就在于程序在对 collection 进行迭代时，某个线程对该 collection 在结构上对其做了修改，这时迭代器就会抛出 ConcurrentModificationException 异常信息，从而产生 fail-fast。

## **三、fail-fast解决办法** ##

这里有两种解决方案：

方案一：在遍历过程中所有涉及到改变modCount值得地方全部加上synchronized或者直接使用Collections.synchronizedList，这样就可以解决。但是不推荐，因为增删造成的同步锁可能会阻塞遍历操作。

方案二：使用CopyOnWriteArrayList来替换ArrayList。

CopyOnWriteArrayList为何物？ArrayList 的一个线程安全的变体，其中所有可变操作（add、set 等等）都是通过对底层数组进行一次新的复制来实现的。 该类产生的开销比较大，但是在两种情况下，它非常适合使用。

CopyOnWriterArrayList所代表的核心概念就是：任何对array在结构上有所改变的操作（add、remove、clear等），CopyOnWriterArrayList都会copy现有的数据，再在copy的数据上修改，这样就不会影响COWIterator中的数据了，修改完成之后改变原有数据的引用即可。同时这样造成的代价就是产生大量的对象，同时数组的copy也是相当有损耗的。