Paragraph 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, "法");，方法是不会报错的。
Paragraph 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的值没有变化，于是异常就产生了。
Paragraph 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都有的。
Paragraph 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没有机会得到执行。
有一点要注意，不抛出该异常的情况是先拿到了迭代的元素，而后进行集合操作，否则依然会抛异常。
本文同步发表于 CSDN ：http://blog.csdn.net/ta_men/article/details/78084060
转载请注明出处。欢迎提出建议。
是为简书第一篇。
