Java ConcurrentModificationException异常剖析

为什么会出现ConcurrentModificationException异常？

之前在“Java Collections Framework学习笔记之Collection接口”中在介绍Iterator时有提到过ConcurrentModificationException这个异常。我们被提醒：在直接使用Iterator（不是通过增强for循环间接使用）时，要记住一个基本法则：如果对正在被迭代的集合进行结构上的改变（如add、remove、clear），那么迭代器就不再合法（会抛出ConcurrentModificationException）。
那么，我们就具体来看看这个ConcurrentModificationException异常

环境为JDK1.8

看下面一段代码

    public static void main(String[] args) {

        ArrayList<Integer> list = new ArrayList<>();
        list.add(2);
        Iterator<Integer> iterator = list.iterator();

        while (iterator.hasNext()) {
            Integer integer  = iterator.next();
            if (integer == 2)
                list.remove(integer);
        }
    }

运行报错：

 Exception in thread "main" java.util.ConcurrentModificationException
        at java.util.AbstractList$Itr.checkForComodification(Unknown Source)
        at java.util.AbstractList$Itr.next(Unknown Source)

我们根据上面程序的代码，一步步看ArrayList的源码：
由这一句

        Iterator<Integer> iterator = list.iterator();

我们进入到ArrayList的iterator()方法的实现：

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

从这段代码看到返回的是一个Itr类型对象的引用，接下来进入Itr()看其具体实现。在JDK1.8中，ArrayList中的Itr()是AbstractList.Itr的优化版。与在AbstractList中的Itr一样，在ArrayList中的Itr也是一个内部类

    private class Itr implements Iterator<E> {

         // 下一个要返回的元素的索引
        int cursor; 

        // 返回的最后一个元素的索引，即上一个元素的索引，如果没有返回-1 
        int lastRet = -1; 

        // 对ArrayList修改次数的期望值，初始值为modCount
        int expectedModCount = 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();
        }
    }

此时变量的初始值为：
- modCount: modCount = 0 modCount是AbstractList中的一个成员变量，表示对List的修改次数（每次add/remove都会使modCount+/-），其定义是protected transient int modCount = 0;
- expectedModCount = 0
- cursor = 0
- lastRet = -1
- size = 1

让我们的程序继续走

 while (iterator.hasNext()) {

进入到iterator的hasNext()方法中

        public boolean hasNext() {
            return cursor != size; // 
        }

如果下一个元素的下标和ArrayList大小不相等，说明后面还有元素。这个很好理解，如果相等了，那就是访问到最后一个元素了。
当hasNext()返回true后，进入while内部，继续跟着程序走：

            Integer integer  = iterator.next();

进入到iterator的next()方法，我们的程序会通过next()获取到下标为0的元素

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor; // i = 0
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1; // cursor = 1
            return (E) elementData[lastRet = i]; // lastRet = 0
        }

此时变量的值为：
- modCount = 0
- expectedModCount = 0
- cursor = 1
- lastRet = 0
- size = 1
继续看我们的代码

            if (integer == 2)
                list.remove(integer);

如果当前元素值为2，则进入ArrayList的remove()方法

    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

进入fastRemove()

    private void fastRemove(int index) {
        modCount++; // modCount = 1

        //接下来删除元素
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // 置为null让GC工作
    }

第一次while循环顺利完成，此时变量的值为：
- modCount = 1
- expectedModCount = 0
- cursor = 1
- lastRet = 0
- size = 0
接下来再次进入while，根据hasNext()判断cursor和size不等，继续进入循环内部，调用iterator的next()方法，在前面贴出来的next()方法中我们可以看到，会首先调用Itr类的checkForComodification()

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

因为此时的modCount = 1，而expectedModCount = 0，则抛出ConcurrentModificationException异常

关键点就在于：list.remove()使得modCount和expectedModCount值不相等

这也就解释了开头我们提到的，为什么“对正在被迭代的集合进行结构上的改变（如add、remove、clear），那么迭代器就不再合法（会抛出ConcurrentModificationException）”

在单线程环境下解决该异常

在Itr类中也有一个remove()方法

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

这个remove方法也是调用了ArrayList的remove，但是多了一步expectedModCount = modCount; 所以删除时使用Itr的remove()就可以避免抛出ConcurrentModificationException了，不过要注意ArrayList迭代器的remove方法是不含参的，也就是说使用这个方法只能删除它刚看到的值（next()后）。

    public static void main(String[] args) {

        ArrayList<Integer> list = new ArrayList<>();
        list.add(2);
        Iterator<Integer> iterator = list.iterator();

        while (iterator.hasNext()) {
            Integer integer  = iterator.next();
            if (integer == 2)
                iterator.remove();
        }
    }