Java ConcurrentModificationException 异常分析与解决方案

本文主要是介绍Java ConcurrentModificationException 异常分析与解决方案，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Java ConcurrentModificationException 异常分析与解决方案

单线程

异常情况举例

只要抛出出现异常，可以肯定的是代码一定有错误的地方。先来看看都有哪些情况会出现ConcurrentModificationException异常，下面以ArrayList remove 操作进行举例：
使用的数据集合：
List myList = new ArrayList();

       myList.add( "1");myList.add( "2");myList.add( "3");myList.add( "4");myList.add( "5");

以下三种情况都会出现异常：Iterator<String> it = myList.iterator();while (it.hasNext()) {String value = it.next();if (value.equals( "3")) {myList.remove(value);  // error}}for (Iterator<String> it = myList.iterator(); it.hasNext();) {String value = it.next();if (value.equals( "3")) {myList.remove(value);  // error}}for (String value : myList) {System. out.println( "List Value:" + value);if (value.equals( "3")) {myList.remove(value);  // error}}

异常信息如下：
Exception in thread “main” java.util.ConcurrentModificationException
at java.util.AbstractList $I t r . c h ec k F or C o m o d i f i c a t i o n (U nkn o w n S o u rce) a t ja v a . u t i l . A b s t r a c t L i s t$ Itr.next(Unknown Source)

根本原因

以上都有3种出现异常的情况有一个共同的特点，都是使用Iterator进行遍历，且都是通过ArrayList.remove(Object) 进行删除操作。
想要找出根本原因，直接查看ArrayList源码看为什么出现异常：

public class ArrayList<E> extends AbstractList<E>implements Cloneable, Serializable, RandomAccess {@Override public boolean remove(Object object) {Object[] a = array;int s = size;if (object != null) {for (int i = 0; i < s; i++) {if (object.equals(a[i])) {System.arraycopy(a, i + 1, a, i, --s - i);a[s] = null;  // Prevent memory leaksize = s;modCount++;  // 只要删除成功都是累加return true;}}} else {for (int i = 0; i < s; i++) {if (a[i] == null) {System.arraycopy(a, i + 1, a, i, --s - i);a[s] = null;  // Prevent memory leaksize = s;modCount++;  // 只要删除成功都是累加return true;}}}return false;}   @Override public Iterator<E> iterator() {return new ArrayListIterator();}   private class ArrayListIterator implements Iterator<E> {......// 全局修改总数保存到当前类中/** The expected modCount value */private int expectedModCount = modCount;@SuppressWarnings("unchecked") public E next() {ArrayList<E> ourList = ArrayList.this;int rem = remaining;// 如果创建时的值不相同，抛出异常if (ourList.modCount != expectedModCount) {throw new ConcurrentModificationException();}if (rem == 0) {throw new NoSuchElementException();}remaining = rem - 1;return (E) ourList.array[removalIndex = ourList.size - rem];}   ......}
}

List、Set、Map 都可以通过Iterator进行遍历，这里仅仅是通过List举例，在使用其他集合遍历时进行增删操作都需要留意是否会触发ConcurrentModificationException异常。

解决方案

上面列举了会出现问题的几种情况，也分析了问题出现的根本原因，现在来总结一下怎样才是正确的，如果避免遍历时进行增删操作不会出现ConcurrentModificationException异常。

public class ArrayList<E> extends AbstractList<E>implements Cloneable, Serializable, RandomAccess {@Override public boolean remove(Object object) {Object[] a = array;int s = size;if (object != null) {for (int i = 0; i < s; i++) {if (object.equals(a[i])) {System.arraycopy(a, i + 1, a, i, --s - i);a[s] = null;  // Prevent memory leaksize = s;modCount++;  // 只要删除成功都是累加return true;}}} else {for (int i = 0; i < s; i++) {if (a[i] == null) {System.arraycopy(a, i + 1, a, i, --s - i);a[s] = null;  // Prevent memory leaksize = s;modCount++;  // 只要删除成功都是累加return true;}}}return false;}   @Override public Iterator<E> iterator() {return new ArrayListIterator();}   private class ArrayListIterator implements Iterator<E> {......// 全局修改总数保存到当前类中/** The expected modCount value */private int expectedModCount = modCount;@SuppressWarnings("unchecked") public E next() {ArrayList<E> ourList = ArrayList.this;int rem = remaining;// 如果创建时的值不相同，抛出异常if (ourList.modCount != expectedModCount) {throw new ConcurrentModificationException();}if (rem == 0) {throw new NoSuchElementException();}remaining = rem - 1;return (E) ourList.array[removalIndex = ourList.size - rem];}   ......}
}

输出结果都是：List Value:[1, 2, 4, 5] ，不会出现异常。
以上4种解决办法在单线程中测试完全没有问题，但是如果在多线程中呢？

多线程

同步异常情况举例

上面针对ConcurrentModificationException异常在单线程情况下提出了4种解决方案，本来是可以很哈皮的洗洗睡了，但是如果涉及到多线程环境可能就不那么乐观了。
下面的例子中开启两个子线程，一个进行遍历，另外一个有条件删除元素：

  final List<String> myList = createTestData();new Thread(new Runnable() {@Overridepublic 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() {@Overridepublic void run() {for (Iterator<String> 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();

输出结果：
遍历集合 value = 1
删除元素 value = 1
遍历集合 value = 2
删除元素 value = 2
遍历集合 value = 3
删除元素 value = 3
Exception in thread “Thread-0” 删除元素 value = 4
java.util.ConcurrentModificationException
at java.util.AbstractList $I t r . c h ec k F or C o m o d i f i c a t i o n (U nkn o w n S o u rce) a t ja v a . u t i l . A b s t r a c t L i s t$ Itr.next(Unknown Source)
at list.ConcurrentModificationExceptionStudy$1.run(ConcurrentModificationExceptionStudy.java:42)
at java.lang.Thread.run(Unknown Source)
删除元素 value = 5
结论：
上面的例子在多线程情况下，仅使用单线程遍历中进行删除的第1种解决方案使用it.remove()，但是测试得知4种的解决办法中的1、2、3依然会出现问题。
接着来再看一下JavaDoc对java.util.ConcurrentModificationException异常的描述：
当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
说明以上办法在同一个线程执行的时候是没问题的，但是在异步情况下依然可能出现异常。

尝试方案

在所有遍历增删地方都加上synchronized或者使用Collections.synchronizedList，虽然能解决问题但是并不推荐，因为增删造成的同步锁可能会阻塞遍历操作。
推荐使用ConcurrentHashMap或者CopyOnWriteArrayList。
CopyOnWriteArrayList注意事项
- CopyOnWriteArrayList不能使用Iterator.remove()进行删除。
- CopyOnWriteArrayList使用Iterator且使用List.remove(Object);会出现如下异常：
  java.lang.UnsupportedOperationException: Unsupported operation remove
  at java.util.concurrent.CopyOnWriteArrayList$ListIteratorImpl.remove(CopyOnWriteArrayList.java:804)

解决方案

单线程情况下列出4种解决方案，但是发现在多线程情况下仅有第4种方案才能在多线程情况下不出现问题。

           List<String> myList = new CopyOnWriteArrayList<String>();myList.add( "1");myList.add( "2");myList.add( "3");myList.add( "4");myList.add( "5");new Thread(new Runnable() {@Overridepublic 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() {@Overridepublic void run() {for (int i = 0; i < myList.size(); i++) {String value = myList.get(i);System.out.println("删除元素 value = " + value);if (value.equals( "3")) {myList.remove(value);i--; // 注意                           }try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}).start();

输出结果：
删除元素 value = 1
遍历集合 value = 1
删除元素 value = 2
遍历集合 value = 2
删除元素 value = 3
遍历集合 value = 3
删除元素 value = 4
遍历集合 value = 4
删除元素 value = 5
遍历集合 value = 5