Java并发修改异常的源码解析

代码复现

List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");

for (String str : list) {
    if ("a".equals(str)) {
        list.remove("a");
    }
}

出现并发修改异常 ConcurrentModificationException

产生原因

at java.base/java.util.ArrayList$Itr.next(ArrayList.java:996)
异常出现的位置出现在ArrayList类中内部类Itr中的checkForComodification方法

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

当一个名为modCount的变量值不等于expectedModCount的变量值时，异常对象被抛出。

modCount:集合在结构上修改的次数

protected transient int modCount = 0;

expectedModCount:预测集合在结构上修改的次数

// 删除指定索引位置上的对象
public E remove(int index) {
    rangeCheck(index);  // 检查此索引是否存在

    modCount++; 		// modCount+1
    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;
}
// 删除
public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);    // 所调用方法内部modCount+1
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);	// 所调用方法内部modCount+1
                return true;
            }
    }
    return false;
}

 private void fastRemove(int index) {
     modCount++;			// 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的源码中我们可以看到，当集合执行添加或者删除操作时，modCount会发生改变（modCount++）。

当程序执行forEach遍历时（如案例），实际是 调用Itertor的hasNext方法，然后再调用next方法。

Itertor 中维护了cursor， lastRet，expectedModCount 三个成员变量。

当在遍历的时候执行remove 方法，modCount 会发生改变modCount++, 但是 expectedModCount并不会发生改变。因此在执行 next 方法的 checkForComodification 时，modCount++ 和 expectedModCount 并不相等，会抛出ConcurrentModificationException。

next 方法：取出数据

public E next() {
    /**
    * 判定expectedModCount与modCount之间是否相等，如果不相等，则抛出
    * concurrentModificationException
    **/
    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;    // 加一是为了使cursor变成下一次遍历要取的值的索引
    return (E) elementData[lastRet = i]; // 给lastRet赋值，此时的i已经变成了上一次取出值的索引
}

final void checkForComodification() {
    if (modCount != expectedModCount)
        // 当不相等时，跑出异常
        throw new ConcurrentModificationException();
}