java中的fast-fail机制

概念

fail-fast 机制是java集合(Collection)中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件。

 

分析

先看一个代码：

public class Test {
    private static List<Integer> list = new ArrayList<>();
    public static void main(String[] args) {
        Thread t1 = new ThreadOne();
        Thread t2 = new ThreadTwo();
        t1.start();
        t2.start();
    }

    static void print(){
        Iterator<Integer> iter = list.iterator();
        while(iter.hasNext()){
            System.out.println(iter.next());
        }
    }

    static class ThreadOne extends Thread{
        @Override
        public void run(){
            for(int i=0; i<3; i++){
                list.add(i);
                print();
            }
        }
    }

    static class ThreadTwo extends Thread{
        @Override
        public void run(){
            for(int i=0; i<3; i++){
                list.add(i);
                print();
            }
        }
    }
}

执行结果如下：

 

 

 

可以看到， 出现了ConcurrentModificationException异常，这就是fast-fail机制。

我们都已经知道了，fail-fast快速失败是在迭代的时候产生的，但是是如何产生的呢？下面我们再来深入的分析一下：

根本原因：

从前面我们知道fail-fast是在操作迭代器时产生的。现在我们来看看ArrayList中迭代器的源代码：

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();
            }
        }

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

 

从上面的源代码我们可以看出，迭代器在调用next()、remove()方法时都是调用checkForComodification()方法，它检测modCount == expectedModCount ？ 若不等则抛出ConcurrentModificationException 异常，从而产生fail-fast机制。

到了这一步我们也知道了，想要弄清楚fail-fast机制，首先我们需要搞清楚modCount 和expectedModCount。

expectedModCount 是在IteratorTest中定义的：

int expectedModCount = modCount;

所以他的值是不可能会修改的，所以会变的就是modCount。

modCount是在 AbstractList 中定义的，为全局变量：

protected transient int modCount = 0;

那么他什么时候因为什么原因而发生改变呢？请看ArrayList的源码：

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;
    }


public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }v


private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

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

 

对于ArrayLis来说，只要是涉及了改变ArrayList元素的个数的方法都会导致modCount的改变。所以我们这里可以判断由于expectedModCount 与modCount的改变不同步，导致两者之间不等，从而产生fail-fast机制。

 

单线程下面的fast-fail机制

事实上，即使是单线程下也有可能会出现这种情况。

不要在 foreach 循环里进行元素的 remove/add 操作。remove 元素请使用 Iterator 方式，如果并发操作，需要对 Iterator 对象加锁。

通过反编译你会发现 foreach 语法糖底层其实还是依赖 Iterator 。不过， remove/add 操作直接调用的是集合自己的方法，而不是 Iterator 的 remove/add方法

这就导致 Iterator 莫名其妙地发现自己有元素被 remove/add ，然后，它就会抛出一个 ConcurrentModificationException 来提示用户发生了并发修改异常。这就是单线程状态下产生的 fail-fast 机制。

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

    private static void test(){
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(1);
        list.add(1);
        list.add(1);
        for(Integer i: list){
            if(i == 1){
                list.remove((Object)i);
            }
        }
    }
}

 

 

 

解决方案

我们如何去规避这种情况呢？这里有两种解决方案：

• 方案一：在遍历过程中所有涉及到改变modCount值得地方全部加上synchronized或者直接使用Collections.synchronizedList（不推荐）

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

CopyOnWriteArrayList为什么能解决这个问题呢？CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。CopyOnWriteArrayList中add/remove等写方法是需要加锁的，目的是为了避免Copy出N个副本出来，导致并发写。但是。CopyOnWriteArrayList中的读方法是没有加锁的。

我们只需要记住一句话，那就是CopyOnWriteArrayList是线程安全的，所以我们在多线程的环境下面需要去使用这个就可以了。