Java集合之ConcurrentModificationException(并发修改异常)分析

前言

今天写LeetCode遇到一道题，我想利用作为方法参数的一个集合作为返回的值，来达到节省空间的目的：

public List<Interval> merge(List<Interval> intervals) {}

意思就是，我想对集合intervals进行修改，然后返回值就传修改后的intervals。

然后顺势就联想到了并发修改异常，之前只是知道个概念，并没有仔细思考过。今天就来分析一下ConcurrentModificationException。

ConcurrentModificationException

ConcurrentModificationException是开发中一个常见的异常，多发生于对一个Collection进行边遍历边做影响size变化的操作时，比如说遍历集合同时向集合中添加新的元素。

举例

下面我们进行三种操作：

1.利用for循环遍历集合的同时添加元素

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        for (int i = 0; i < list.size(); i++) {
            if (list.get(i) == 2) {
                list.add(10);
            }
        }

没有问题。

2.利用迭代器遍历集合的同时添加元素

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            if (iterator.next() == 2) {
                list.add(10);
            }
        }

出现了问题，编译器提示：Exception in thread “main” java.util.ConcurrentModificationException。

3.利用超级for循环遍历集合的同时添加元素

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        for (int num : list) {
            if (num == 2) {
                list.add(10);
            }
        }

同样出现了问题，编译器提示：Exception in thread “main” java.util.ConcurrentModificationException。

分析

以上使用的是ArrayList，那么我们来看一下ArrayList中关于迭代器的源码(Android SDK 23中的Open JDK源码)：

    @Override public Iterator<E> iterator() {
        return new ArrayListIterator();
    }

    private class ArrayListIterator implements Iterator<E> {
        ……
        /** The expected modCount value */
        private int expectedModCount = modCount;

        @SuppressWarnings("unchecked") public E next() {
            ArrayList<E> ourList = ArrayList.this;
            int rem = remaining;
            if (ourList.modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
            if (rem == 0) {
                throw new NoSuchElementException();
            }
            remaining = rem - 1;
            return (E) ourList.array[removalIndex = ourList.size - rem];
        }
        ……
    }

调用iterator()会返回一个ArrayListIterator对象，ArrayListIterator初始化的时候，会将外部类ArrayList(其实是ArrayList的父类AbstractList中的)的成员变量modCount的值赋给expectedModCount。

然而我们向集合中添加元素的时候，改变了modCount的值：

    @Override public boolean add(E object) {
        Object[] a = array;
        int s = size;
        if (s == a.length) {
            Object[] newArray = new Object[s +
                    (s < (MIN_CAPACITY_INCREMENT / 2) ?
                     MIN_CAPACITY_INCREMENT : s >> 1)];
            System.arraycopy(a, 0, newArray, 0, s);
            array = a = newArray;
        }
        a[s] = object;
        size = s + 1;
        modCount++;
        return true;
    }

而expectedModCount的值没有变，这时候再调用next()，会走进如下判断分支：

            if (ourList.modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }

抛出ConcurrentModificationException。

至于超级for循环遍历呢？其实for-each是个语法糖，编译器会把它转化成迭代器遍历，所以同样会出错。

iterator()不行，我们其实还可以使用listIterator()，它是ArrayList的父类AbstractList中的方法，它返回的是一个FullListIterator对象。我们增删元素就利用FullListIterator的remove()和add()，如下：

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        ListIterator<Integer> listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            if (listIterator.next().equals(2)) {
                listIterator.add(10);
            }
        }

不会出现问题。

首先它的remove()和add()中调用的就是AbstractList的remove()和add()。

其次它会将expectedModCount的值与modCount的值进行同步，具体可以去查看源码，这里就不做分析了。

参考：Java并发修改错误ConcurrentModificationException分析