解决办法:
1、采用迭代器来迭代非线程安全的容器。
2、可以采用线程安全的容器。
问题导入
经常在迭代集合元素时,会想对集合做修改(add/remove)操作,类似下面这段代码:
Iterator<Integer> it = list.iterator()
while (it.hasNext()) {
Integer val = it.next();
if (val == 5) {
// 注意:这里仍然是调用list的删除方法。
list.remove(val);
// 正确删除:it.remove();
}
}
运行这段代码,会抛出异常java.util.ConcurrentModificationException。
解决办法
(以ArrayList来讲解)在ArrayList中,它的修改操作(add/remove)都会对modCount
这个字段+1,modCount表示修改的次数,也可以看做版本号,每次集合中的元素被修改后,都会+1(即使溢出)。
// AbstractList的源码定义
protected transient int modCount = 0;
// ArrayList的remove()
public E remove(int index) {
rangeCheck(index);
// 修改次数加1,但是并没有重新给expectedModCount 赋值
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;
}
接下来再看看AbsrtactList中iteraor方法。
public Iterator<E> iterator() {
return new Itr();
}
它返回一个内部类,这个类实现了iterator接口,代码如下:
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 {
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);
if (lastRet < cursor)
cursor--;
lastRet = -1;
// 修改expectedModCount 的值,重新赋值,保持一致。
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
// 检查当前版本号与期望版本号是否相同
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
在内部类Itr中,有一个字段expectedModCount
,初始化时等于modCount,即当我们调用list.iterator()返回迭代器时,该字段被初始化为等于modCount。在类Itr中next/remove方法都有调用checkForComodification()方法,在该方法中检测modCount == expectedModCount,如果不相当则抛出异常ConcurrentModificationException。
前面说过,在集合的修改操作(add/remove)中,都对modCount进行了+1。
在看看刚开始提出的那段代码,在迭代过程中,执行list.remove(val),使得modCount+1,当下一次循环时,执行 it.next(),checkForComodification方法发现modCount != expectedModCount,则抛出异常。
【解决办法】
如果想要在迭代的过程中,执行删除元素操作怎么办?
再来看看内部类Itr的remove()方法,在删除元素后,有这么一句expectedModCount = modCount,同步修改expectedModCount 的值。所以,如果需要在使用迭代器迭代时,删除元素,可以使用迭代器提供的remove方法。对于add操作,则在整个迭代器迭代过程中是不允许的。 其他集合(Map/Set)使用迭代器迭代也是一样。
HashMap的问题
Fail-Fast 机制
我们知道 java.util.HashMap 不是线程安全的,因此如果在使用迭代器的过程中有其他线程修改了map,那么将抛出ConcurrentModificationException,这就是所谓fail-fast策略。这一策略在源码中的实现是通过 modCount 域,modCount 顾名思义就是修改次数,对HashMap 内容的修改都将增加这个值,那么在迭代器初始化过程中会将这个值赋给迭代器的 expectedModCount。在迭代过程中,判断 modCount 跟 expectedModCount 是否相等,如果不相等就表示已经有其他线程修改了 Map。
所以在这里和大家建议,当大家遍历那些非线程安全的数据结构时,尽量使用迭代器
Java中增强for循环的原理(字节码中理解)
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
for (int val : list) {
System.out.println(val);
list.remove((Integer)3);
}
}
结果会抛异常:
Exception in thread “main” java.util.ConcurrentModificationException
public static void main(java.lang.String[]);
Code:
0: new #2 // class java/util/ArrayList
3: dup
4: invokespecial #3 // Method java/util/ArrayList."<init>":()V
7: astore_1
8: aload_1
9: iconst_1
10: invokestatic #4 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
13: invokeinterface #5, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
18: pop
19: aload_1
20: iconst_2
21: invokestatic #4 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
24: invokeinterface #5, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
29: pop
30: aload_1
31: iconst_3
32: invokestatic #4 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
35: invokeinterface #5, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
40: pop
41: aload_1
42: iconst_4
43: invokestatic #4 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
46: invokeinterface #5, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
51: pop
52: aload_1
// 底层字节码显示,for循环仍然调用的Iterator的
53: invokeinterface #6, 1 // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
58: astore_2
59: aload_2
// 调用Iterator的hashNext(),判断是否有下一个元素
60: invokeinterface #7, 1 // InterfaceMethod java/util/Iterator.hasNext:()Z
65: ifeq 102
68: aload_2
// 调用Iterator的next(),得到下一个元素
69: invokeinterface #8, 1 // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
74: checkcast #9 // class java/lang/Integer
// 拆箱操作
77: invokevirtual #10 // Method java/lang/Integer.intValue:()I
80: istore_3
81: getstatic #11 // Field java/lang/System.out:Ljava/io/PrintStream;
84: iload_3
85: invokevirtual #12 // Method java/io/PrintStream.println:(I)V
88: aload_1
89: iconst_3
90: invokestatic #4 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
// 删除元素使用的list.remove(),会抛出异常。
93: invokeinterface #13, 2 // InterfaceMethod java/util/List.remove:(Ljava/lang/Object;)Z
98: pop
99: goto 59
102: return