Java中出现java.util.ConcurrentModificationException的原理探究和解决办法

文章开始首先要感谢两位提供思路的伙伴，他们是网易博客ID为“风不可追”的伙伴，博客链接是http://fine36.blog.163.com/blog/static/189251005201258113857343/，第二位是提供了ArrayList注释翻译的伙伴，在知乎上ID为lantaozi，链接为http://www.zhihu.com/question/24086463。非常感谢他们！！！

来说一下应用场景，我拿到一个List< E >类型的供应商列表，循环该列表，将供应商code为某某某的从列表中删除，于是简化一下代码如下：

List<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");

for(String s : list){
if(s.equalsIgnoreCase("A")){
list.remove(s);
}
}

这样写就会报错，错误如下：

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 com.param.ListTest.main(ListTest.java:18)

于是我修改了一下代码，修改后的代码如下：

for(int i=0 ; i<list.size();i++){
if(list.get(i).equalsIgnoreCase("A")){
list.remove(i);
}
}

这样就不报错，我就很诧异，于是开始研究原因，首先开始调试代码：



初始化的list，有5个元素A,B,C,D,E没错，size=5也对，大家注意list中modCount这个变量，执行remove语句之后：



只有B,C,D,E四个元素了，size=4了，说明remove成功，继续进入for循环，此时报错java.util.ConcurrentModificationException，按F5进行step into操作，代码如下（此时进入到ArrayList.class）：

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

很明显，hasNext方法返回是true，进入next方法，第一行就是一个方法调用，大家注意，checkForComodification();进入到该方法：

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

如果modCount不等于expectedModCount的话，就抛出该异常。调试就到这里，抛出了异常，那么很明显是这两个变量不等，不等的原因在哪？继续探究，代码回溯到list.remove(s);F5进入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;
}

/*
* Private remove method that skips bounds checking and does not
* return the value removed.
*/
private void fastRemove(int index) {
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
}

传递进来的Object对象非空所以进入到else，调用了fastRemove方法删除元素，该方法第一行就对modCount进行了++操作，而初始化数组的时候，或者对数组add的时候：

public void add(E e) {
checkForComodification();

try {
int i = cursor;
ArrayList.this.add(i, e);
cursor = i + 1;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}

try里的最后一行，是保证了modCount与expectedModCount两个变量一致的，所以说，remove(s)之后，这两个变量就不等了，抛出异常。这样做的原因是防止遍历列表的时候破坏列表结构，保证线程安全，这种情况应该是在多线程使用的时候居多。

那么问题来了，执行后面一段代码，就是使用index循环的时候怎么不抛出异常呢？我们再来回顾一下代码片段：

for(int i=0 ; i<list.size();i++){
if(list.get(i).equalsIgnoreCase("A")){
list.remove(i);
}
}

remove(i);删除元素之后，一样的对modCount进行了++操作，但是在for循环里边就没有checkForComodification();这个方法了，也就是说不对modCount和expectedModCount进行判断，所以就不抛出异常。这就是这两种for循环的根本区别所在。

还有另外一种循环，迭代

Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
if(iterator.next().equalsIgnoreCase("A")){
iterator.remove();
}
}

这种方式也不会报错，我们看看具体实现方式：

private class Itr implements Iterator<E> {
int cursor;       // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;

初始化迭代器的时候就保证了modCount和expectedModCount的一致性，这招很nice啊！再看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();
}
}

也保证了这两个变量的一致性，这里更是nice，所以用迭代器的话整个过程都保证了线程同步或者说线程安全，那么就不会报错。

综上所述：

for(String s : list)这种for循环，modCount和expectedModCount不会同步修改，而在循环中会判断两个变量如果不等就抛出异常

for(int i=0;i< list.size();i++)这种for循环，modCount和expectedModCount也不会同步修改，而在循环中不会判断两个变量相等情况，所以不抛出异常

使用迭代器，无论是add操作还是remove操作，都能保证modCount和expectedModCount的一致性，所以不会抛出异常

总结：

在实际开发过程中，一开始我使用了for(int i=0;i< list.size();i++)这种for循环，结果有些元素没法删除，也不报错，实在找不到原因就换了一种for循环，就是for(String s : list)这种for循环，结果报错了，解决思路是，new一个removeList，遍历时候，removeList.add()，等到遍历结束后，在用list.removeAll(removeList)这种方法来删除。代码如下：

//new一个removeList
List<String> removeList = new ArrayList<String>();

for(String s : list){
if(s.equalsIgnoreCase("A")){
removeList.add(s);
}
}
//遍历结束后，删除
list.removeAll(removeList);

最后，希望能帮助大家解决一些困扰，有问题欢迎随时提出~~~