1.1 问题复现
public void test1() { ArrayList<Integer> arrayList = new ArrayList<>(); for (int i = 0; i < 20; i++) { arrayList.add(Integer.valueOf(i)); } // 复现方法一 Iterator<Integer> iterator = arrayList.iterator(); while (iterator.hasNext()) { Integer integer = iterator.next(); if (integer.intValue() == 5) { arrayList.remove(integer); } } // 复现方法二 iterator = arrayList.iterator(); for (Integer value : arrayList) { Integer integer = iterator.next(); if (integer.intValue() == 5) { arrayList.remove(integer); } } }
1.2、问题原因分析
先来看实现方法一,方法一中使用Iterator遍历ArrayList, 抛出异常的是iterator.next(),看下Iterator next方法实现源码
public E next() {
checkForComodification();
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];
}final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
在next方法中首先调用了checkForComodification方法,该方法会判断modCount是否等于expectedModCount,不等于就会抛出java.util.ConcurrentModificationExcepiton异常。
我们接下来跟踪看一下modCount和expectedModCount的赋值和修改。
modCount是ArrayList的一个属性,继承自抽象类AbstractList,用于表示ArrayList对象被修改次数。
protected transient int modCount = 0;
整个ArrayList中修改modCount的方法比较多,有add、remove、clear、ensureCapacityInternal等,凡是设计到ArrayList对象修改的都会自增modCount属性。
在创建Iterator的时候会将modCount赋值给expectedModCount,在遍历ArrayList过程中,没有其他地方可以设置expectedModCount了,因此遍历过程中expectedModCount会一直保持初始值20(调用add方法添加了20个元素,修改了20次)。
final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); }
在执行next方法时,遇到modCount != expectedModCount方法,导致抛出异常java.util.ConcurrentModificationException。
明白了抛出异常的过程,但是为什么要这么做呢?很明显这么做是为了阻止程序员在不允许修改的时候修改对象,起到保护作用,避免出现未知异常。
引用网上的一段解释,点击查看解释来源
Iterator 是工作在一个独立的线程中,并且拥有一个 mutex 锁。 Iterator 被创建之后会建立一个指向原来对象的单链索引表,当原来的对象数量发生变化时,这个索引表的内容不会同步改变。 当索引指针往后移动的时候就找不到要迭代的对象,所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。 所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象, Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。
再来分析下第二种for循环抛异常的原因:
public void forEach(Consumer<? super E> action) {
Objects.requireNonNull(action);
final int expectedModCount = modCount;
@SuppressWarnings("unchecked")
final E[] elementData = (E[]) this.elementData;
final int size = this.size;
for (int i=0; modCount == expectedModCount && i < size; i++) {
action.accept(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
在for循环中一开始也是对expectedModCount采用modCount进行赋值。在进行for循环时每次都会有判定条件modCount == expectedModCount,当执行完arrayList.remove(integer)之后,该判定条件返回false退出循环,然后执行if语句,结果同样抛出java.util.ConcurrentModificationException异常。
这两种复现方法实际上都是同一个原因导致的。
1.3 问题解决方案
上述的两种复现方法都是在单线程运行的,先来说明单线程中的解决方案:
public void test2() {
ArrayList<Integer> arrayList = new ArrayList<>();
for (int i = 0; i < 20; i++) {
arrayList.add(Integer.valueOf(i));
}Iterator<Integer> iterator = arrayList.iterator();
while (iterator.hasNext()) {
Integer integer = iterator.next();
if (integer.intValue() == 5) {
iterator.remove();
}
}
}
这种解决方案最核心的就是调用iterator.remove()方法。我们看看该方法源码为什么这个方法能避免抛出异常
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
在iterator.remove()方法中,同样调用了ArrayList自身的remove方法,但是调用完之后并非就return了,而是expectedModCount = modCount重置了expectedModCount值,使二者的值继续保持相等。
针对forEach循环并没有修复方案,因此在遍历过程中同时需要修改ArrayList对象,则需要采用iterator遍历。
上面提出的解决方案调用的是iterator.remove()方法,如果不仅仅是想调用remove方法移除元素,还想增加元素,或者替换元素,是否可以呢?浏览Iterator源码可以发现这是不行的,Iterator只提供了remove方法。
但是ArrayList的内部类ListItr实现了ListIterator接口,并继承了内部类Iter(实现了Iterator<E>),这些操作都是可以实现的,使用示例如下:
public void test3() {
ArrayList<Integer> arrayList = new ArrayList<>();
for (int i = 0; i < 20; i++) {
arrayList.add(Integer.valueOf(i));
}ListIterator<Integer> iterator = arrayList.listIterator();
while (iterator.hasNext()) {
Integer integer = iterator.next();
if (integer.intValue() == 5) {
iterator.set(Integer.valueOf(6));
iterator.remove();
iterator.add(integer);
}
}
}
二、 多线程情况下的问题分析及解决方案
2.1 问题复现
public void test4() {
ArrayList<Integer> arrayList = new ArrayList<>();
for (int i = 0; i < 20; i++) {
arrayList.add(Integer.valueOf(i));
}Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
ListIterator<Integer> iterator = arrayList.listIterator();
while (iterator.hasNext()) {
System.out.println("thread1 " + iterator.next().intValue());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
ListIterator<Integer> iterator = arrayList.listIterator();
while (iterator.hasNext()) {
System.out.println("thread2 " + iterator.next().intValue());
iterator.remove();
}
}
});
thread1.start();
thread2.start();
}
在个测试代码中,开启两个线程,一个线程遍历,另外一个线程遍历加修改。程序输出结果如下
thread1 0
thread2 0
thread2 1
thread2 2
thread2 3
thread2 4
thread2 5
thread2 6
thread2 7
thread2 8
thread2 9
thread2 10
thread2 11
thread2 12
thread2 13
thread2 14
thread2 15
thread2 16
thread2 17
thread2 18
thread2 19
Exception in thread "Thread-0" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
at java.util.ArrayList$Itr.next(ArrayList.java:851)
at com.snow.ExceptionTest$1.run(ExceptionTest.java:74)
at java.lang.Thread.run(Thread.java:745)Process finished with exit code 0
2.2 问题分析
从上面代码执行结果可以看出thread2 遍历结束后,thread1 sleep完1000ms准备遍历第二个元素,next的时候抛出异常了。我们从时间点分析一下抛异常的原因
时间点 | arrayList.modCount | thread1 iterator.expectedModCount | thread2 iterator.expectedModCount |
thread start,初始化iterator | 20 | 20 | 20 |
thread2.remove()调用之后 | 21 | 20 | 21 |
两个thread都是使用的同一个arrayList,thread2修改完后modCount = 21,此时thread2的expectedModCount = 21 可以一直遍历到结束;thread1的expectedModCount仍然为20,因为thread1的expectedModCount只是在初始化的时候赋值,其后并未被修改过。因此当arrayList的modCount被thread2修改为21之后,thread1想继续遍历必定会抛出异常了。
在这个示例代码里面,两个thread,每个thread都有自己的iterator,当thread2通过iterator方法修改expectedModCount必定不会被thread1感知到。这个跟ArrayList非线程安全是无关的,即使这里面的ArrayList换成Vector也是一样的结果,不信上测试代码:
public void test5() {
Vector<Integer> vector = new Vector<>();
for (int i = 0; i < 20; i++) {
vector.add(Integer.valueOf(i));
}Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
ListIterator<Integer> iterator = vector.listIterator();
while (iterator.hasNext()) {
System.out.println("thread1 " + iterator.next().intValue());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
ListIterator<Integer> iterator = vector.listIterator();
while (iterator.hasNext()) {
Integer integer = iterator.next();
System.out.println("thread2 " + integer.intValue());
if (integer.intValue() == 5) {
iterator.remove();
}
}
}
});
thread1.start();
thread2.start();
}
执行后输出结果为:
thread1 0
thread2 0
thread2 1
thread2 2
thread2 3
thread2 4
thread2 5
thread2 6
thread2 7
thread2 8
thread2 9
thread2 10
thread2 11
thread2 12
thread2 13
thread2 14
thread2 15
thread2 16
thread2 17
thread2 18
thread2 19
Exception in thread "Thread-0" java.util.ConcurrentModificationException
at java.util.Vector$Itr.checkForComodification(Vector.java:1184)
at java.util.Vector$Itr.next(Vector.java:1137)
at com.snow.ExceptionTest$3.run(ExceptionTest.java:112)
at java.lang.Thread.run(Thread.java:745)Process finished with exit code 0
test5()方法执行结果和test4()是相同的,那如何解决这个问题呢?
2.3 多线程下的解决方案
2.3.1 方案一:iterator遍历过程加同步锁,锁住整个arrayList
public static void test5() {
ArrayList<Integer> arrayList = new ArrayList<>();
for (int i = 0; i < 20; i++) {
arrayList.add(Integer.valueOf(i));
}Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (arrayList) {
ListIterator<Integer> iterator = arrayList.listIterator();
while (iterator.hasNext()) {
System.out.println("thread1 " + iterator.next().intValue());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
});Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (arrayList) {
ListIterator<Integer> iterator = arrayList.listIterator();
while (iterator.hasNext()) {
Integer integer = iterator.next();
System.out.println("thread2 " + integer.intValue());
if (integer.intValue() == 5) {
iterator.remove();
}
}
}
}
});
thread1.start();
thread2.start();
}