关于并发修改

Part one : 什么是并发修改异常?

并发修改异常即ConcurrentModificationException，当方法不允许对一个对象进行并发修改（简单理解为同时修改），抛出此异常。

例如：线程 A 正在使用迭代器（Iterator）对集合（Collection）进行遍历，此时线程 B 对该集合进行了修改（改变了原有的结构，如添加和删除），那么方法将会抛出ConcurrentModificationException。

除多线程修改情况外，单线程操作同样可能出现该异常。
例如：方法 A 在迭代器遍历集合时，调用自身的remove()或add()方法，那么同样会抛出该异常。

public class ConcurrentModificationExceptionTest {

    public static void main(String[] args) {

        List<String> list = new ArrayList<>();  // 创建集合
        list.add("测");  // 添加元素
        list.add("试");
        list.add("代");
        list.add("码");

        Iterator<String> iterator = list.iterator();    //  获得迭代器
        while(iterator.hasNext()) {
            list.remove(3);     // 通过集合删除
            System.out.println(iterator.next());
        }

    }
}

控制台报错：

Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859)
    at java.util.ArrayList$Itr.next(ArrayList.java:831)
    at ConcurrentModificationExceptionTest.main(ConcurrentModificationExceptionTest.java:18)

如果进行修改，如list.set(2, "法");，方法是不会报错的。

Part two : 原因是什么?

首先，集合的迭代是通过while循环不断执行迭代器的next()方法达到遍历集合的效果。debug进入iterator.hasNext()方法中，代码如下：

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

其中cursor代表下一个元素下标（index），size代表集合的长度。因为集合的长度总是比最大下标大1（集合长度不为0时），所以当cursor = size时表示已经遍历完成，结束循环（hasNext()返回false）。

第一次进入循环，方法走到代码list.remove(3);，进入remove()方法中：

// 这里的源码注释请参考JDK API
    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;
    }

首先进行了判断索引是否越界方法rangeCheck(index)，接着修改次数+1（此时modCount为4+1），取出当前索引对应的集合中的元素作为返回值，然后进行数组（ArrayList底层为数组，一个能自动扩容的数组）拷贝，同时将数组最后一个索引位置置为null，注释说“清除这个位置元素后，让垃圾回收器来干掉它”。返回被删除的元素后，remove方法结束。

进入iterator.next()方法中：

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();    // -----------    【1】
            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];
        }

其中【1】方法的代码为：

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

可以看到，进入next()方法后，首先进行了并发修改的判断。【1】方法中的expectedModCount表示“期望修改次数”，它在迭代器被创建时通过int expectedModCount = modCount;（Arraylist源码823行）被赋值。

重点就在这里了：当我们使用集合的方法改变了数组的结构，使得modCount的值+1，而expectedModCount的值没有变化，于是异常就产生了。

Part three : 怎么解决?

答曰: 使用迭代器自身的方法。

比如使用Iterator删除集合最后一个元素：

        while(iterator.hasNext()) {
            if (list.get(list.size()-1).equals(iterator.next())) {
                iterator.remove();
            }
        }

在iterator.remove()方法内：

        public void remove() {
            if (lastRet < 0)    // 最后一个元素的索引不能小于0
                throw new IllegalStateException();
            checkForComodification();    // 并发修改检查

            try {
                ArrayList.this.remove(lastRet);    // 底层还是通过集合的删除方法
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;    // 【同步了修改次数】
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

可以看到，通过迭代器自身方法会同步modCount和expectedModCount的值，因此在并发修改检查时可以顺利通过。

同样的,也可以使用ListIterator进行删除。ListIterator与Iterator相比，还多了add()方法。

需要注意的是，ListIterator迭代器只有List集合才有，Set集合没有；而Iterator是整个Collection都有的。

Part four : 不合群的倒数第二个元素 ：）

请看这段代码：

public class ConcurrentModificationExceptionTest {

    public static void main(String[] args) {

        List<String> list = new LinkedList<>(); // 创建集合
        list.add("测");  // 添加元素
        list.add("试");
        list.add("代");
        list.add("码");

        Iterator<String> iterator = list.iterator();    //  获得迭代器
        while(iterator.hasNext()) {

            String element = iterator.next();
            if (list.get(list.size()-2).equals(element)) { //当迭代到最后第2个元素
                list.remove(list.size()-2); // 使用集合删除
            }
        }
        System.out.println(list);
    }

}

结果正常输出，没有异常！
…
…
还记得循环的条件吗？没错，是iterator.hasNext()，它的返回值为return cursor != size。当循环到倒数第二个元素时，调用集合方法将该元素删除，此时的cursor为2（一共四个元素），size从3变为2，即cursor = size，循环条件不满足，跳出循环，因此检查并发修改的方法checkForComodification没有机会得到执行。

有一点要注意，不抛出该异常的情况是先拿到了迭代的元素，而后进行集合操作，否则依然会抛异常。

此文同步发表于简书：http://www.jianshu.com/p/27e6239e1afe

转载请注明出处。欢迎提出建议。