ArrayList的fail-fast和fail-safe机制

ArrayList的fail-fast

fail-fast是集合中比较常见的错误检测机制。一般在对集合元素进行遍历的时候发生。打个不恰当的比喻，正在清点仓库的每样物品，突然被加塞进来或者被拿走了一些，为了保证清点结果准确，当作清点有误，要重新开始。对于ArrayList来说，首先它是线程不安全的，快速失败机制也常见于多线程的情况，单线程也会发生。ArrayList的快速失败发生的前提是必须是用了迭代器进行遍历。下面用几种情况说明发生的原理。

1. 单线程-普通for遍历

import java.util.ArrayList;

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i<10; i++) {
            list.add(i);
        }

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

结果能猜到，没有报错，程序正常运行

2. 单线程-迭代器遍历

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

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i<10; i++) {
            list.add(i);
        }
        Iterator<Integer> it = list.iterator();

        while (it.hasNext()) {
            list.add(1);
            System.out.println(it.next());
        }
    }
}

打开ArrayList.java源码文件。

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

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

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

可以明显看到，抛出错误的原因在于checkForComodification()函数会比较modCount和expectedModCount两个变量是否相等，如果不等就会抛出错误。而checkForComodification()只在Itr这个类中出现，这个类实现了Iterator接口，是一个迭代器。

    public Iterator<E> iterator() {
        return new Itr();
    }

在源码中可以找到，当我们使用了list.iterator()的时候，其实就是实例化了一个Itr对象。再来看一下modCount和expectedModCount两个变量，一开始的时候modCount赋值给了expectedModCount，这时候应该是相等的，那什么时候会不等呢，再来看下源码中的改变modCount的相关函数。

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    
    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }
    
	public E remove(int index) {
        rangeCheck(index);

        modCount++;   // Increments 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;
    }

	private void fastRemove(int index) {
        modCount++;   // Increments modCount!!
        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
    }

	public void clear() {
        modCount++;    // Increments modCount!!

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

	public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

注意：这里的方法是ArrayList的remove,add等，而Itr迭代器也实现有自己的remove方法，通过源码可以看当通过迭代器自己的方法操作ArrayList是不会报错的。

这里就不把所有的函数都列出来了，能看出remove、add、clear、addAll等操作都会增加modCount的值。所以当对ArrayList进行迭代器遍历的时候，进行上述ArrayList的方法操作时，就会抛出ConcurrentModificationException()错误。

这里对多线程的情况就不具体列出了，ArrayList本来就是线程不安全，多线程操作更容易发生快速失败现象。

3. 单线程-增强for遍历

import java.util.ArrayList;

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i<10; i++) {
            list.add(i);
        }

        for(int num:list){
            list.add(num);
            System.out.println(num);
        }
    }
}

发现增强for循环也报错了，不应该只是在迭代器便利的时候才可能出现这种情况吗。难道增强for循环的也是用迭代器实现的吗。接着对编译后的class文件进行查看

        Iterator var4 = list.iterator();

        while(var4.hasNext()) {
            int num = (Integer)var4.next();
            list.add(num);
            System.out.println(num);
        }

果然，增强for循环的底层就是用了迭代器模式去实现的。

ArrayList的fail-safe

任何对集合结构的修改都会在一个复制的集合上进行修改，因此不会抛出ConcurrentModificationException

基于拷贝内容的优点是避免了Concurrent Modification Exception，但同样地，迭代器并不能访问到修改后的内容，即：迭代器遍历的是开始遍历那一刻拿到的集合拷贝，在遍历期间原集合发生的修改迭代器是不知道的。

场景：java.util.concurrent包下的容器都是安全失败，可以在多线程下并发使用，并发修改。

fail-safe机制有两个问题

（1）需要复制集合，产生大量的无效对象，开销大

（2）无法保证读取的数据是目前原始数据结构中的数据。