假如有两个线程A与线程B，线程A对集合C进行迭代操作时，线程B改变了集合C的数据结构，此时会报出ConcurrentModificationException异常，这就是Fail-Fast(快速失败)，其为java中集合操作的快速检错机制。留下30分钟，一看究竟。

一、Fail-Fast案例

public class FailFastTest {
    private static List<Integer> list = new ArrayList<Integer>();

    private static class ThreadOne extends Thread{
        public void run(){
            Iterator<Integer> it = list.iterator();
            while(it.hasNext()){
                Integer i = it.next();
                System.out.println("ThreadOne is using : "+ i);
                try {
                    Thread.sleep(5);
                } catch (Exception e) {
                    e.getStackTrace();
                }
            }
        }
    }
    
    private static class ThreadTwo extends Thread{
        public void run(){
            int i = 0;
            while(i < 6){
                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进行迭代操作时，ThreadTwo对其进行数据结构的修改，程序报出异常提醒

二、源码解读

    // JDK1.8内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; // 由modCount决定，值不会改变

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

// 在迭代器中的next()、remove()和forEachRemaining()方法中
// 均包含checkForComodification()，而checkForComodification() // 方法
// 会抛出ConcurrentModificationException()异常，
// 关键在于检测modCount与expectedModCount是否相同

    //JDK1.8内ArrayList中包含的方法，大都包含modCount++操作
    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;
    }

    private void fastRemove(int index) {
        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
    }

• 对ArrayList进行迭代时，会不断检测expectedCount和modCount的值，如果其他操作修改了全局的modCount的值，则会报出异常；

三、解决方案

• 推荐使用CopyOnWriteArrayList，先来解读一下源码：

    // JDK1.8内CopyOnWriteArrayList中迭代器不进行expectedCount和modCount检查
    static final class COWIterator<E> implements ListIterator<E> {
        /** Snapshot of the array */
        private final Object[] snapshot;
        /** Index of element to be returned by subsequent call to next.  */
        private int cursor;

        private COWIterator(Object[] elements, int initialCursor) {
            cursor = initialCursor;
            snapshot = elements;
        }

        public boolean hasNext() {
            return cursor < snapshot.length;
        }

        public boolean hasPrevious() {
            return cursor > 0;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            if (! hasNext())
                throw new NoSuchElementException();
            return (E) snapshot[cursor++];
        }

    // JDK1.8内CopyOnWriteArrayList中迭代器不进行expectedCount和modCount检查
    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

// add()方法，本质是对于原数组的copy，不会存在修改集合数据结构的操作，其他方法类似

CopyOnWriteArrayList的核心原理：对于Array的操作（增删改查），都是基于复制到新copy数组，不会改变迭代器的对象，修改完成后改变原有数据的引用即可。

今天就暂时到这里啦！毕业季在匆忙与顾念中离去，回首一年前的毕业季，做好眼前事，珍惜校园时光。