目录
一、引起异常的代码
二、foreach原理
三、从ArrayList源码找原因
四、单线程解决方案
五、在多线程环境下的解决方法
一、引起异常的代码
以下三种的遍历集合对象时候，执行集合的remove和add的操作时候都会引起java.util.ConcurrentModificationException异常。
注：set方法不会导致该异常，看了源码set没有改变modcount。快速失败迭代器在遍历时不允许结构性修改，javadoc中对此的解释是“结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。”
public class Test { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("a"); list.add("b"); list.add("b"); list.add("b"); // foreach循环 for (String str : list) { if (str.equals("b")) { list.remove(str); } } // for循环借助迭代器遍历Collection对象 for (Iterator<String> it = list.iterator(); it.hasNext();) { String value = it.next(); if (value.equals("b")) { list.remove(value); } } // 迭代器遍历 Iterator<String> it = list.iterator(); while (it.hasNext()) { String value = it.next(); if (value.equals("3")) { list.remove(value); } } System.out.println(list); } }
抛出的异常：
从异常信息可以发现，异常出现在checkForComodification()方法中。不忙看checkForComodification()方法的具体实现，先根据程序的代码一步一步看ArrayList源码的实现。
二、foreach原理
（直接看结论即可）
首先、追究foreach的原理，暂时删除其他的遍历方法，只保留foreach的写法：
public class Test { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("a"); list.add("b"); list.add("b"); list.add("b"); // foreach循环 for (String str : list) { if (str.equals("b")) { list.remove(str); } } } }
编译后的.class文件（eclipse 直接打开可以查看），截取其中for循环的部分：
44 aload_1 [list] 45 invokeinterface java.util.List.iterator() : java.util.Iterator [29] [nargs: 1] 50 astore_3 51 goto 81 54 aload_3 55 invokeinterface java.util.Iterator.next() : java.lang.Object [33] [nargs: 1] 60 checkcast java.lang.String [39] 63 astore_2 [str] 64 aload_2 [str] 65 ldc <String "b"> [27] 67 invokevirtual java.lang.String.equals(java.lang.Object) : boolean [41] 70 ifeq 81 73 aload_1 [list] 74 aload_2 [str] 75 invokeinterface java.util.List.remove(java.lang.Object) : boolean [44] [nargs: 2] 80 pop 81 aload_3 82 invokeinterface java.util.Iterator.hasNext() : boolean [47] [nargs: 1] 87 ifne 54
第45行：调用List中的list.iterator()方法，获取集合的迭代器Iterator对象。
第51行：注意，goto 81，因此是调用第81、82行的hasNext()方法。
第55行：调用next方法，获取第一个list中第一个元素：String字符串。
第67行：调用String的equals方法比较。
第75行：注意，此时remove方法仍然是list的方法，而不是迭代器的remove。
第82行：调用迭代器的hasNext()方法，判断是否继续遍历。
经过整理、优化，foreach的底层代码可以使用下方的代码替换：
public void test1() { ArrayList<String> list = new ArrayList<String>(); list.add("b"); list.add("b"); list.add("b"); Iterator<String> iterator = list.iterator();//获取迭代器 while (iterator.hasNext()) {//继续循环 String value = iterator.next();//获取遍历到的值 if (value.equals("b")) { list.remove(value);//list的remove } } }
结论：
1、遍历集合的增强for循环最终都是使用的Iterator迭代器。
2、集合的remove（add）方法却仍然调用list的方法，而不是Iterator的方法。
不使用迭代器和不使用增强for循环是不会引起ConcurrentModificationException的，参看单线程解决方案3.不使用Iterator进行遍历（即使用for ( int i = 0; i < myList.size(); i++)形式）
三、从ArrayList源码找原因
跟进ArrayList的源码看, 搜索iterator()方法看其获得的迭代器, 发现没有! 于是追其父类 AbstractList, iterator()方法返回new Itr()!
查看Itr中的两个重要的方法: hasNext与next
public boolean hasNext() { return cursor != size(); } public E next() { checkForComodification(); try { E next = get(cursor); lastRet = cursor++; return next; } catch (IndexOutOfBoundsException e) { checkForComodification(); throw new NoSuchElementException(); } }
看next中调用的checkForComodification(), 在remove方法中也调用了checkForComodification()！接着checkForComodification()方法里面在做些什么事情！
final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); }
所以在迭代的过程中，hasNext()是不会抛出ConcurrentModificationException的， next和remove可能方法会抛！ 抛异常的标准就是modCount != expectedModCount！继续跟踪这两个变量,在Itr类的成员变量里对expectedModCount初始化的赋值是int expectedModCount = modCount;
那么这个modCount呢.? 这个是AbstractList中的一个protected的变量, 在对集合增删的操作中均对modCount做了修改, 因为这里是拿ArrayList为例, 所以直接看ArrayList中有没有覆盖父类的add? 结果发现覆盖了
public boolean add(E e) { ensureCapacity(size + 1); // Increments modCount!! elementData[size++] = e; return true; } public void ensureCapacity(int minCapacity) { modCount++; int oldCapacity = elementData.length; if (minCapacity > oldCapacity) { Object oldData[] = elementData; int newCapacity = (oldCapacity * 3)/2 + 1; if (newCapacity < minCapacity) newCapacity = minCapacity; // minCapacity is usually close to size, so this is a win: elementData = Arrays.copyOf(elementData, newCapacity); } }
remove方法中也做了modCount++,
ArrayList中的remove做的事情：
public boolean remove(Object paramObject) { int i; if (paramObject == null) { for (i = 0; i < size; i++) { if (elementData[i] == null) { fastRemove(i); return true; } } } else { for (i = 0; i < size; i++) { if (paramObject.equals(elementData[i])) { fastRemove(i); return true; } } } return false; } private void fastRemove(int paramInt) { modCount += 1; int i = size - paramInt - 1; if (i > 0) { System.arraycopy(elementData, paramInt + 1, elementData, paramInt, i); } elementData[(--size)] = null; }
当我获得迭代器之前, 无论对集合做了多少次添加删除操作, 都没有关系, 因为对expectedModCount赋值是在获取迭代器的时候初始化的.
关键点就在于：调用list.remove()或list.add()方法导致modCount和expectedModCount的值不一致。
四、单线程解决方案
1、对于没有使用foreach循环，代码里使用了迭代器的程序，可以把list.remove(value);替换为：iterator.remove();
看下 iterator.remove();的具体实现：
public void remove() { if (lastRet < 0) { throw new IllegalStateException(); } checkForComodification(); try { remove(lastRet); if (lastRet < cursor) { cursor -= 1; } lastRet = -1; expectedModCount = modCount; } catch (IndexOutOfBoundsException localIndexOutOfBoundsException) { throw new ConcurrentModificationException(); } }
iterator.remove();相比list.remove(value);多了一步expectedModCount = modCount; 此时保证了checkForComodification()方法检查通过。
代码改成如下所示：
public void test1() { List<String> list = new ArrayList<String>(); list.add("a"); list.add("b"); list.add("c"); list.add("b"); Iterator<String> it = list.iterator(); while (it.hasNext()) { String value = it.next(); if (value.equals("b")) { // list.remove(value); it.remove(); } } }
2、使用临时的集合，把需要remove的元素保存在临时的集合中，最后再把临时集合一起remove掉。
public void test2() { List<String> list = new ArrayList<String>(); list.add("a"); list.add("b"); list.add("c"); list.add("b"); // 临时的list_add List<String> list_add = new ArrayList<String>(); for (String str : list) { if (str.equals("b")) { list_add.add(str); } } list.removeAll(list_add);//最后统一移除 System.out.println(list); }
3.不使用Iterator进行遍历，即使用for ( int i = 0; i < myList.size(); i++)形式。需要注意的是自己保证索引正常
for ( int i = 0; i < myList.size(); i++) { String value = myList.get(i); System. out.println( "List Value:" + value); if (value.equals( "3")) { myList.remove(value); // ok i--; // 因为位置发生改变，所以必须修改i的位置 } } System. out.println( "List Value:" + myList.toString());
五、在多线程环境下的解决方法
下面的例子中开启两个子线程，一个进行遍历，另外一个有条件删除元素：
final List myList = createTestData(); new Thread(new Runnable() { @Override public void run() { for (String string : myList) { System.out.println("遍历集合 value = " + string); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } }).start(); new Thread(new Runnable() { @Override public void run() { for (Iterator it = myList.iterator(); it.hasNext();) { String value = it.next(); System.out.println("删除元素 value = " + value); if (value.equals( "3")) { it.remove(); } try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } }).start();
Exception in thread "Thread-0" 删除元素 value = 4 java.util.ConcurrentModificationException at java.util.AbstractList$Itr.checkForComodification(Unknown Source) at java.util.AbstractList$Itr.next(Unknown Source) at list.ConcurrentModificationExceptionStudy$1.run(ConcurrentModificationExceptionStudy.java:42) at java.lang.Thread.run(Unknown Source) 删除元素 value = 5
有可能有朋友说ArrayList是非线程安全的容器，换成Vector就没问题了，实际上换成Vector还是会出现这种错误。
原因在于，虽然Vector的方法采用了synchronized进行了同步，但是实际上通过Iterator访问的情况下，每个线程里面返回的是不同的iterator，也即是说expectedModCount是每个线程私有。假若此时有2个线程，线程1在进行遍历，线程2在进行修改，那么很有可能导致线程2修改后导致Vector中的modCount自增了，线程2的expectedModCount也自增了，但是线程1的expectedModCount没有自增，此时线程1遍历时就会出现expectedModCount不等于modCount的情况了。
结论：
上面的例子在多线程情况下，使用it.remove()，
说明使用it.remove()的办法在同一个线程执行的时候是没问题的，但是在多线程进行迭代情况下依然可能出现异常。
参看iterator.remove();的具体实现，如果在iterator.remove()的expectedModCount = modCount;之前线程切换，则另一个线程检查expectedModCount和modCount不一致，抛ConcurrentModificationException异常
解决方案 ：
1）在使用iterator迭代的时候使用synchronized或者Lock进行同步；
2）使用并发容器CopyOnWriteArrayList代替ArrayList和Vector。
CopyOnWriteArrayList注意事项
(1) CopyOnWriteArrayList不能使用Iterator.remove()进行删除。
(2) CopyOnWriteArrayList使用Iterator且使用List.remove(Object);会出现如下异常：
java.lang.UnsupportedOperationException: Unsupported operation remove
at java.util.concurrent.CopyOnWriteArrayList$ListIteratorImpl.remove(CopyOnWriteArrayList.java:804)
原因是CopyOnWriteArrayList的阉割版迭代器COWIterator源码中
static final class COWIterator<E> implements ListIterator<E> { public void remove() { throw new UnsupportedOperationException(); } //省略 }
六.Java快速失败（fail-fast）和安全失败（fail-safe）
当错误发生时，如果系统立即关闭，即是快速失败，系统不会继续运行。运行中发生错误，它会立即停止操作，错误也会立即暴露。而安全失败系统在错误发生时不会停止运行。它们隐蔽错误，继续运行，而不会暴露错误。这两种模式，孰优孰优，是系统设计中常讨论的话题，在此，我们只讨论java中的快速失败和安全失败迭代器。
Java快速失败与安全失败迭代器 :
java迭代器提供了遍历集合对象的功能，集合返回的迭代器有快速失败型的也有安全失败型的，快速失败迭代器在迭代时如果集合类被修改，立即抛出ConcurrentModificationException异常，而安全失败迭代器不会抛出异常，因为它是在集合类的克隆对象上操作的。我们来看看快速失败和 安全失败迭代器的具体细节。
java快速失败迭代器 :
大多数集合类返回的快速失败迭代器在遍历时不允许结构性修改（结构性修改指添加，删除） 当遍历的同时被结构性修改，就会抛出ConcurrentModificationException异常，而当集合是被迭代器自带的方法（如remove()）修改时，不会抛出异常。
Java安全失败迭代器 :
安全失败迭代器在迭代中被修改，不会抛出任何异常，因为它是在集合的克隆对象迭代的，所以任何对原集合对象的结构性修改都会被迭代器忽略，但是这类迭代器有一些缺点，其一是它不能保证你迭代时获取的是最新数据，因为迭代器创建之后对集合的任何修改都不会在该迭代器中更新。
java.util包下的集合类都是快速失败的，java.util.concurrent包下的容器都是安全失败如ConcurrentHashMap
ConcurrentHashMap迭代器复制了一份map：
static class BaseIterator<K,V> extends Traverser<K,V> { final ConcurrentHashMap<K,V> map; Node<K,V> lastReturned; BaseIterator(Node<K,V>[] tab, int size, int index, int limit, ConcurrentHashMap<K,V> map) { super(tab, size, index, limit); this.map = map; advance(); }
https://blog.csdn.net/shaohe18362202126/article/details/83795991
https://blog.csdn.net/qq_30051139/article/details/54019515?utm_source=blogxgwz3
https://blog.csdn.net/izard999/article/details/6708738
https://www.cnblogs.com/dolphin0520/p/3933551.html
2073
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
