Java ConcurrentModificationException 异常分析与解决方案

转载 2016年08月30日 11:25:04

一、单线程

  1. 异常情况举例

只要抛出出现异常,可以肯定的是代码一定有错误的地方。先来看看都有哪些情况会出现ConcurrentModificationException异常,下面以ArrayList remove 操作进行举例:

使用的数据集合:

List<string> myList = new ArrayList<string>();

myList.add( "1");
myList.add( "2");
myList.add( "3");
myList.add( "4");
myList.add( "5");</string></string>

以下三种情况都会出现异常:

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.AbstractListItr.checkForComodification(UnknownSource)atjava.util.AbstractListItr.next(Unknown Source)

  1. 根本原因

以上都有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 leak
                    size = 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 leak
                    size = 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异常。

  1. 解决方案

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

// 1 使用Iterator提供的remove方法,用于删除当前元素
 for (Iterator<string> it = myList.iterator(); it.hasNext();) {
     String value = it.next();
      if (value.equals( "3")) {
          it.remove();  // ok
     }
}
System. out.println( "List Value:" + myList.toString());

 // 2 建一个集合,记录需要删除的元素,之后统一删除             
List<string> templist = new ArrayList<string>();
 for (String value : myList) {
      if (value.equals( "3")) {
          templist.remove(value);
     }
}
 // 可以查看removeAll源码,其中使用Iterator进行遍历
myList.removeAll(templist);
System. out.println( "List Value:" + myList.toString());        

  // 3. 使用线程安全CopyOnWriteArrayList进行删除操作
List<string> myList = new CopyOnWriteArrayList<string>();
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( "4");
          myList.add( "6");
          myList.add( "7");
     }
}
System. out.println( "List Value:" + myList.toString());

 // 4. 不使用Iterator进行遍历,需要注意的是自己保证索引正常
 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());

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

二、多线程

  1. 同步异常情况举例

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

final List<string> 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<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.AbstractListItr.checkForComodification(UnknownSource)atjava.util.AbstractListItr.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异常的描述:
当方法检测到对象的并发修改,但不允许这种修改时,抛出此异常。
说明以上办法在同一个线程执行的时候是没问题的,但是在异步情况下依然可能出现异常。

  1. 尝试方案

(1) 在所有遍历增删地方都加上synchronized或者使用Collections.synchronizedList,虽然能解决问题但是并不推荐,因为增删造成的同步锁可能会阻塞遍历操作。
(2) 推荐使用ConcurrentHashMap或者CopyOnWriteArrayList。

  1. 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)

  1. 解决方案

单线程情况下列出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() {

     @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 (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

OK,搞定

三、参考资料

《How to Avoid ConcurrentModificationException when using an Iterator》

Java中常见的异常分析

JavaException: 1、Error 2、RuntimeException运行时异常 3、Exception 4、throw用户自定义异常 异常类分两大类型:Error类代表了编译和...
  • qq_32671287
  • qq_32671287
  • 2017年02月18日 10:40
  • 499

Java常见异常原因以及解决方案

Java常见异常原因以及解决方案一、ConcurrentModificationException(转)单线程 异常原因 在使用迭代器Iterator进行遍历时,进行了remove操作。(其他增删操...
  • yangnan0110
  • yangnan0110
  • 2017年04月20日 18:31
  • 171

java中异常的处理和分析

昨天实训上午讲了异常,感觉有点印象模糊,特意回顾仔细看了下,所以今天写下对java中异常的处理和分析 一.异常的简介和分类   异常:有异于常态,和正常情况不一样,有错误出现阻止当前方法或作用域,...
  • u010785140
  • u010785140
  • 2015年07月22日 08:50
  • 645

关于内存溢出的原因分析及解决方案探讨

内存溢出是指应用系统中存在无法回收的内存或使用的内存过多,最终使得程序运行要用到的内存大于虚拟机能提供的最大内存。    引起内存溢出的原因有很多种,常见的有以下几种:  1.内存中加载的数据量过于庞...
  • xiangbole
  • xiangbole
  • 2017年12月01日 09:36
  • 142

Java常见异常和解决办法

1、java.lang.ArithmeticException 算术运算异常,因为除数为0,所以引发了算数异常 2、Java.lang.StringIndexOutOfBoundsExce...
  • u012630060
  • u012630060
  • 2017年04月27日 21:12
  • 605

java异常——分析堆栈跟踪元素+使用异常机制的技巧

【0】README0.1) 本文描述+源代码均 转自 core java volume 1, 旨在理解 java异常——分析堆栈跟踪元素+使用异常机制的技巧 的相关知识;【1】分析堆栈跟踪元素相关...
  • PacosonSWJTU
  • PacosonSWJTU
  • 2015年12月09日 19:22
  • 2524

Java中关于OOM的场景及解决方法

Java中关于OOM的场景及解决方法 1、OOM for Heap=>例如:java.lang.OutOfMemoryError: Java heapspace 【分析】  此OOM是由于JVM...
  • tianyazaiheruan
  • tianyazaiheruan
  • 2015年10月20日 15:41
  • 2356

java深入浅出解析异常机制

三月份啦,月初第一篇写一份异常机制的完全解析,表明这个月努力学习的决心! 以下长文预警!!! java中的异常处理的目的在于通过使用少量的代码,使得程序有着强大的鲁棒性,并且这种异常处理机制会让...
  • QuinnNorris
  • QuinnNorris
  • 2017年03月02日 19:38
  • 2154

数据库连接异常的解决过程

首先先简述一下遇到的问题,今天早上来了之后,网站突然报404的问题,不废话,直接看tomcat的日志吧,日志如下: ### Error querying database. Cause: com....
  • ksdb0468473
  • ksdb0468473
  • 2017年03月01日 11:07
  • 540

懒加载异常的解决办法

最近在做一个项目,采用的是SSH2框架,要实现一个级联功能,具体实现如下: Department部门包括许多下级Department,在查询第一级Department时,一切OK,但是当查询第一级D...
  • randomnet
  • randomnet
  • 2014年01月24日 09:45
  • 13239
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java ConcurrentModificationException 异常分析与解决方案
举报原因:
原因补充:

(最多只允许输入30个字)