java.util.ConcurrentModificationException 出现的原因和解决办法

56 阅读 0 评论 37 点赞

我是靠谱客的博主长情发带，最近开发中收集的这篇文章主要介绍java.util.ConcurrentModificationException 出现的原因和解决办法，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

用iterator遍历集合时碰到java.util.ConcurrentModificationException这个异常，

下面以List为例来解释为什么会报java.util.ConcurrentModificationException这个异常，代码如下：

Java代码

public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
list.add("6");
list.add("7");
List<String> del = new ArrayList<String>();
del.add("5");
del.add("6");
del.add("7");
<span style="color: #ff0000;">for(String str : list){
if(del.contains(str)) {
list.remove(str);
}
}</span>
}

运行这段代码会出现如下异常：

Java代码

Exception in thread "main" java.util.ConcurrentModificationException

for(String str : list)　这句话实际上是用到了集合的iterator() 方法

JDK java.util. AbstractList类中相关源码

Java代码

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

java.util. AbstractList的内部类Itr的源码如下：

Java代码

private class Itr implements Iterator<E> {
/**
* Index of element to be returned by subsequent call to next.
*/
int cursor = 0;
/**
* Index of element returned by most recent call to next or
* previous. Reset to -1 if this element is deleted by a call
* to remove.
*/
int lastRet = -1;
/**
* The modCount value that the iterator believes that the backing
* List should have. If this expectation is violated, the iterator
* has detected concurrent modification.
*/
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size();
}
public E next() {
checkForComodification(); //检测modCount和expectedModCount的值！！
try {
E next = get(cursor);
lastRet = cursor++;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet); //执行remove的操作
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount; //保证了modCount和expectedModCount的值的一致性，避免抛出ConcurrentModificationException异常
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount) //当modCount和expectedModCount值不相等时，则抛出ConcurrentModificationException异常
throw new ConcurrentModificationException();
}
}

再看一下ArrayList　的　remove方法

Java代码

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++; //只是修改了modCount，因此modCount将与expectedModCount的值不一致
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // Let gc do its work
}

回过头去看看java.util. AbstractList的next()方法

Java代码

public E next() {
checkForComodification(); //检测modCount和expectedModCount的值！！
try {
E next = get(cursor);
lastRet = cursor++;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount) //当modCount和expectedModCount值不相等时，则抛出ConcurrentModificationException异常
throw new ConcurrentModificationException();
}
}

现在真相终于大白了，ArrayList的remove方法只是修改了modCount的值，并没有修改expectedModCount，导致modCount和expectedModCount的值的不一致性，当next()时则抛出ConcurrentModificationException异常

因此使用Iterator遍历集合时，不要改动被迭代的对象，可以使用 Iterator 本身的方法 remove() 来删除对象，Iterator.remove() 方法会在删除当前迭代对象的同时维护modCount和expectedModCount值的一致性。

解决办法如下：

(1) 新建一个集合存放要删除的对象，等遍历完后，调用removeAll(Collection<?> c)方法

把上面例子中迭代集合的代码替换成：

Java代码

List<String> save = new ArrayList<String>();
for(String str : list)
{
if(del.contains(str))
{
save.add(str);
}
}
list.removeAll(save);

(2) 使用Iterator替代增强型for循环：

Java代码

Iterator<String> iterator = list.iterator();
while(iterator.hasNext()) {
String str = iterator.next();
if(del.contains(str)) {
iterator.remove();
}
}

Iterator.remove()方法保证了modCount和expectedModCount的值的一致性，避免抛出ConcurrentModificationException异常。

不过对于在多线程环境下对集合类元素进行迭代修改操作，最好把代码放在一个同步代码块内，这样才能保证modCount和expectedModCount的值的一致性，类似如下：

Java代码

Iterator<String> iterator = list.iterator();
synchronized(synObject) {
while(iterator.hasNext()) {
String str = iterator.next();
if(del.contains(str)) {
iterator.remove();
}
}
}

因为迭代器实现类如：ListItr的next(),previous(),remove(),set(E e),add(E e)这些方法都会调用checkForComodification()，源码:

Java代码

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

曾经写了下面这段对HashMap进行迭代删除操作的错误的代码：

Java代码

Iterator<Integer> iterator = windows.keySet().iterator();
while(iterator.hasNext()) {
int type = iterator.next();
windows.get(type).closeWindow();
iterator.remove();
windows.remove(type); //
}

上面的代码也会导致ConcurrentModificationException的发生。罪魁祸首是windows.remove(type);这一句。

根据上面的分析我们知道iterator.remove();会维护modCount和expectedModCount的值的一致性，而windows.remove(type);这句是不会的。其实这句是多余的，上面的代码去掉这句就行了。

iterator.remove()的源码如下：HashIterator类的remove()方法

Java代码

public void remove() {
if (lastEntryReturned == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
HashMap.this.remove(lastEntryReturned.key);
lastEntryReturned = null;
expectedModCount = modCount; //保证了这两值的一致性
}

HashMap.this.remove(lastEntryReturned.key);这句代码说明windows.remove(type);是多余的，因为已经删除了该key对应的value。

windows.remove(type)的源码：

Java代码

public V remove(Object key) {
if (key == null) {
return removeNullKey();
}
int hash = secondaryHash(key.hashCode());
HashMapEntry<K, V>[] tab = table;
int index = hash & (tab.length - 1);
for (HashMapEntry<K, V> e = tab[index], prev = null;
e != null; prev = e, e = e.next) {
if (e.hash == hash && key.equals(e.key)) {
if (prev == null) {
tab[index] = e.next;
} else {
prev.next = e.next;
}
modCount++;
size--;
postRemove(e);
return e.value;
}
}
return null;
}

上面的代码中，由于先调用了iterator.remove();所以再调用HashMap的remove方法时，key就已经为null了，所以会执行：removeNullKey();

方法，removeNullKey()源码：

Java代码

private V removeNullKey() {
HashMapEntry<K, V> e = entryForNullKey;
if (e == null) {
return null;
}
entryForNullKey = null;
modCount++;
size--;
postRemove(e);
return e.value;
}

不过不管是执行removeNullKey()还是key != null，如果直接调用HashMap的remove方法，都会导致ConcurrentModificationException

这个异常的发生，因为它对modCount++;没有改变expectedModCount的值，没有维护维护索引的一致性。

下面引用一段更专业的解释：

Iterator 是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator 被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。

所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象， Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。

另一种解决办法就是使用并发的集合

//------------------------------------------------------------------------------

public class Coding {
public static void main(String[] args)
{
List<String> s = new CopyOnWriteArrayList<String>();
s.add("a");
s.add("b");
s.add("c");
s.add("d");
Iterator<String> it = s.iterator();
while (it.hasNext()) {
if (it.next().contains("b")) {
s.remove("b");
}
}
System.out.println(s);
}
}

上面这里使用并发的集合也可以解决这个问题了。