异常记录——java.util.ConcurrentModificationException

前几天项目整合的时候，在服务器上测试我负责的功能的时候，出现了一个Exception，之前我本地测试的时候未测试出来。异常信息：java.util.ConcurrentModificationException

老大一眼就看出来了，说是在对List集合遍历的时候，使用了ArrayList的remove(Object o)方法。下面是测试出现异常的方法：

package com.day0219.list;import java.util.ArrayList;import java.util.Iterator;import java.util.List;/** * @author xukai * 测试List集合在循环的时候，使用remove(Object o)方法 */public class TestList {public static void main(String[] args) {List<String> list = new ArrayList<>();// 添加元素for(int i = 1; i < 100; i++){list.add("str_" + i);}// 使用foreach循环遍历List，同时remove某个条件的元素for(String str : list){// 带偶数的removeif(Integer.parseInt(str.substring(4)) % 2 == 0){list.remove(str);}}// 使用Iterator遍历ListIterator<String> iterator = list.iterator();while(iterator.hasNext()){String str = iterator.next();if(Integer.parseInt(str.substring(4)) % 2 == 0){list.remove(str);}}// 打印Listfor(String str : list){System.out.println(list.indexOf(str) + "," + str);}}}

这里使用了两种遍历集合的办法。

前者是jdk5.0新增加的一个循环结构，可以用来处理集合中的每个元素而不用考虑集合下标，格式如下：

for(vaiable : collection) { statement; }

定义一个变量用于暂存集合中的每一个元素，并执行相应的语句块。collection必须是一个数组或者是一个实现了Iterable接口的类对象。

后者使用接口Iterable，实现这个接口允许对象成为 "foreach" 语句的目标。方法iterator(),返回一个在一组 T 类型的元素上进行迭代的迭代器。

两者在使用remove(Object o)方法的时候都会出现异常java.util.ConcurrentModificationException。根据后者分析，方便理解。

异常出现的位置：

可以看到iterator()方法是在ArrayList的父类AbstractList中实现的：

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

内部类：

    private class Itr implements Iterator<E> {        int cursor = 0;        int lastRet = -1;        int expectedModCount = modCount;        public boolean hasNext() {            return cursor != size();        }        public E next() {            checkForComodification();            try {                int i = cursor;                E next = get(i);                lastRet = i;                cursor = i + 1;                return next;            } catch (IndexOutOfBoundsException e) {                checkForComodification();                throw new NoSuchElementException();            }        }        public void remove() {            if (lastRet < 0)                throw new IllegalStateException();            checkForComodification();            try {                AbstractList.this.remove(lastRet);                if (lastRet < cursor)                    cursor--;                lastRet = -1;                expectedModCount = modCount;            } catch (IndexOutOfBoundsException e) {                throw new ConcurrentModificationException();            }        }        final void checkForComodification() {            if (modCount != expectedModCount)                throw new ConcurrentModificationException();        }    }

字段解释：

    protected transient int modCount = 0;

已从结构上修改 此列表的次数。从结构上修改是指更改列表的大小，或者打乱列表，从而使正在进行的迭代产生错误的结果。此字段由iterator 和 listIterator 方法返回的迭代器和列表迭代器实现使用。如果意外更改了此字段中的值，则迭代器（或列表迭代器）将抛出ConcurrentModificationException 来响应 next、remove、previous、set 或add 操作。在迭代期间面临并发修改时，它提供了快速失败 行为，而不是非确定性行为。 

以上为API中文翻译，即异常出现的原因。

下面是异常出现的过程：

list.iterator()//创建一个Itr()类对象，初始化数据

cursor = 0; // 游标

lastRet = -1;  // 上一个索引的位置

expectedModCount = 0; // 迭代器认为后面列表应该有modCount的值。如果这个预期被破坏，迭代器检测到并发修改。

iterator.hasNext();// 判断游标位置是否等于集合大小，等于返回false

iterator.next();// 向下一个移动

执行checkForComodification()，通过。

list.remove(Object o);

该方法的实现：

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

实际执行为fastRemove(index);

    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    }

可以看到首先modCount++，值发生改变，最后把删除的元素的内存地址设置为NULL，方便GC回收。
当下一次执行next()方法的时候，checkForComodification()的判断：

if (modCount != expectedModCount)                throw new ConcurrentModificationException();

抛出异常。
使用foreach遍历集合的原理是相同的，因为foreach循环其实是由Iterator实现的。同样会执行next()方法进行校验，出现同样的异常。

解决：使用iterator.remove()方法

Itr()内部方法

        public void remove() {            if (lastRet < 0)                throw new IllegalStateException();            checkForComodification();            try {                AbstractList.this.remove(lastRet);                if (lastRet < cursor)                    cursor--;                lastRet = -1;                expectedModCount = modCount;            } catch (IndexOutOfBoundsException e) {                throw new ConcurrentModificationException();            }        }

这里执行了expectedModCount = modCount;防止出现异常

while(iterator.hasNext()){String str = iterator.next();if(Integer.parseInt(str.substring(4)) % 2 == 0){iterator.remove();// 变化了}}

如果想使用foreach循环遍历，并且删除，可以重新创建一个List集合用来装

public static void main(String[] args) {List<String> list = new ArrayList<>();// 添加元素for(int i = 1; i < 100; i++){list.add("str_" + i);}List<String> temp = new ArrayList<>();// 使用foreach循环遍历List，同时remove某个条件的元素for(String str : list){// 带偶数的removeif(Integer.parseInt(str.substring(4)) % 2 != 0){temp.add(str);}}list = null;// GC回收// 打印Listfor(String str : temp){System.out.println(temp.indexOf(str) + "," + str);}}

*注：以上测试都是在单线程环境下