集合删除元素出现ConcurrentModificationException异常

集合删除元素出现ConcurrentModificationException异常

在操作集合遍历删除集合中某个元素时，就可能会出现这个异常，那么为什么会产生异常呢？

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
	at java.util.ArrayList$Itr.next(ArrayList.java:851)
	at com.test.ListTest.main(ListTest.java:12)

从上述异常信息可以看到异常产生的位置是在ArrayList.java的901行，点进去看一下

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

可以看到是因为modCount和expectedModCount不相等就抛出了ConcurrentModificationException异常，看下是在哪里调用了这个方法，根据错误信息可以知道是在ArrayList.java:851，再进去看一下

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];
        }

可以看到是在next方法的第一行调用了这个方法，再看下是在哪里调用了next方法，com.test.ListTest.main(ListTest.java:12)

package com.test;

import java.util.ArrayList; 
import java.util.List;

public class ListTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        for (Integer integer : list) {
            list.remove(0);
        }
    } 
}

最终发现是因为增强for循环这边导致的异常，一会我们对增强for循环反编译看一下。先看下remove方法，因为抛出了异常，无法得知list.remove是否执行了，这时候打个断点或者try catch一下看看

看一下发现其实remove是已经执行了的，集合中的元素由3个变成了2个，那么显然remove方法对产生该异常也有一定责任，这时候进去看看remove方法

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

我们发现当执行remove方法的时候modCount自增，因为前面已经发现抛出该异常的原因是因为modCount和expectedModCount不相等，这里的modCount自增了，但是expectedModCount没有改变，所以就抛出了该异常。按照这个发现，大胆猜测一波，在增强for循环中使用add方法也会导致该异常

package com.test;

import java.util.ArrayList;
import java.util.List;

public class ListTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        for (Integer integer : list) {
            list.add(1);
        }

        System.out.println(list.toString());
    }
}

果然

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
	at java.util.ArrayList$Itr.next(ArrayList.java:851)
	at com.test.ListTest.main(ListTest.java:13)

同样的，打个断点看一下，list中的元素也是增加了的，说明add方法已经执行了，进入add方法看看

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

可以看到有一行注解//Increments modCount!!，说明这个方法也导致modCount的增加

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

add调用了ensureCapacityInternal，ensureCapacityInternal又调用了ensureExplicitCapacity，modCount自增1。
这个modCount的作用其实很显然了，就是记录了对集合修改的次数
。
我们再反编译一下我们的增强for循环

for (Iterator localIterator = list.iterator(); localIterator.hasNext(); ) { 
	  Integer integer = (Integer)localIterator.next();
      list.add(Integer.valueOf(1));
    }

可以发现有调用了next方法，这样一来就说得通了，我们再进去iterator()看一下。

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

发现其实就是返回一个Itr对象，再看一下这个类，代码比较长，就贴一部分。

int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

可以看到expectedModCount = modCount。说明modCount和expectedModCount 最初是相等的。再点进去看下modCount

protected transient int modCount = 0;

是有个初始值为0。到此为止的话基本就弄懂了为什么会抛出该异常了。

总结一下，增强for循环本质是使用迭代器，初始化迭代器对象的时候modCount和expectedModCount的值是相等的，在使用remove或者add对集合进行操作的时候，会使modCount的值改变，调用next方法的时候，会去比较modCount的值和expectedModCount，当不一致的时候，就抛出了ConcurrentModificationException异常