Java自学者论坛

 找回密码
 立即注册

手机号码,快捷登录

恭喜Java自学者论坛(https://www.javazxz.com)已经为数万Java学习者服务超过8年了!积累会员资料超过10000G+
成为本站VIP会员,下载本站10000G+会员资源,会员资料板块,购买链接:点击进入购买VIP会员

JAVA高级面试进阶训练营视频教程

Java架构师系统进阶VIP课程

分布式高可用全栈开发微服务教程Go语言视频零基础入门到精通Java架构师3期(课件+源码)
Java开发全终端实战租房项目视频教程SpringBoot2.X入门到高级使用教程大数据培训第六期全套视频教程深度学习(CNN RNN GAN)算法原理Java亿级流量电商系统视频教程
互联网架构师视频教程年薪50万Spark2.0从入门到精通年薪50万!人工智能学习路线教程年薪50万大数据入门到精通学习路线年薪50万机器学习入门到精通教程
仿小米商城类app和小程序视频教程深度学习数据分析基础到实战最新黑马javaEE2.1就业课程从 0到JVM实战高手教程MySQL入门到精通教程
查看: 2783|回复: 0

Java并发--ConcurrentModificationException(并发修改异常)异常原因和解决方法

[复制链接]
  • TA的每日心情
    开心
    前天 08:40
  • 签到天数: 132 天

    [LV.7]常住居民III

    1410

    主题

    1467

    帖子

    6万

    积分

    管理员

    Rank: 9Rank: 9Rank: 9

    积分
    62618
    发表于 2021-4-5 12:07:59 | 显示全部楼层 |阅读模式

      在前面一篇文章中提到,对Vector、ArrayList在迭代的时候如果同时对其进行修改就会抛出java.util.ConcurrentModificationException异常。下面我们就来讨论以下这个异常出现的原因以及解决办法。

      以下是本文目录大纲:

      一.ConcurrentModificationException异常出现的原因

      二.在单线程环境下的解决办法

      三.在多线程环境下的解决方法

      转载原文链接:http://www.cnblogs.com/dolphin0520/p/3933551.html

    一.ConcurrentModificationException异常出现的原因

      先看下面这段代码:

     1 public class Test {  2     public static void main(String[] args) {  3         ArrayList<Integer> list = new ArrayList<Integer>();  4         list.add(2);  5         Iterator<Integer> iterator = list.iterator();  6         while(iterator.hasNext()){  7             Integer integer = iterator.next();  8             if(integer==2)  9  list.remove(integer); 10  } 11  } 12 }

    运行结果:

      

      从异常信息可以发现,异常出现在checkForComodification()方法中。

      我们不忙看checkForComodification()方法的具体实现,我们先根据程序的代码一步一步看ArrayList源码的实现:

      首先看ArrayList的iterator()方法的具体实现,查看源码发现在ArrayList的源码中并没有iterator()这个方法,那么很显然这个方法应该是其父类或者实现的接口中的方法,我们在其父类AbstractList中找到了iterator()方法的具体实现,下面是其实现代码:

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

    从这段代码可以看出返回的是一个指向Itr类型对象的引用,我们接着看Itr的具体实现,在AbstractList类中找到了Itr类的具体实现,它是AbstractList的一个成员内部类,下面这段代码是Itr类的所有实现:

     1 private class Itr implements Iterator<E> {  2     int cursor = 0;  3     int lastRet = -1;  4     int expectedModCount = modCount;  5     public boolean hasNext() {  6            return cursor != size();  7  }  8     public E next() {  9  checkForComodification(); 10         try { 11         E next = get(cursor); 12         lastRet = cursor++; 13         return next; 14         } catch (IndexOutOfBoundsException e) { 15  checkForComodification(); 16         throw new NoSuchElementException(); 17  } 18  } 19     public void remove() { 20         if (lastRet == -1) 21         throw new IllegalStateException(); 22  checkForComodification(); 23  
    24         try { 25         AbstractList.this.remove(lastRet); 26         if (lastRet < cursor) 27             cursor--; 28         lastRet = -1; 29         expectedModCount = modCount; 30         } catch (IndexOutOfBoundsException e) { 31         throw new ConcurrentModificationException(); 32  } 33  } 34  
    35     final void checkForComodification() { 36         if (modCount != expectedModCount) 37         throw new ConcurrentModificationException(); 38  } 39 }

    首先我们看一下它的几个成员变量:

      cursor:表示下一个要访问的元素的索引,从next()方法的具体实现就可看出

      lastRet:表示上一个访问的元素的索引

      expectedModCount:表示对ArrayList修改次数的期望值,它的初始值为modCount。

      modCount是AbstractList类中的一个成员变量

    protected transient int modCount = 0;

    该值表示对List的修改次数,查看ArrayList的add()和remove()方法就可以发现,每次调用add()方法或者remove()方法就会对modCount进行加1操作。

      好了,到这里我们再看看上面的程序:

      当调用list.iterator()返回一个Iterator之后,通过Iterator的hashNext()方法判断是否还有元素未被访问,我们看一下hasNext()方法,hashNext()方法的实现很简单:

    public boolean hasNext() { return cursor != size(); }

    如果下一个访问的元素下标不等于ArrayList的大小,就表示有元素需要访问,这个很容易理解,如果下一个访问元素的下标等于ArrayList的大小,则肯定到达末尾了。

      然后通过Iterator的next()方法获取到下标为0的元素,我们看一下next()方法的具体实现:

    public E next() { checkForComodification(); try { E next = get(cursor); lastRet = cursor++; return next; } catch (IndexOutOfBoundsException e) { checkForComodification(); throw new NoSuchElementException(); } }

    这里是非常关键的地方:首先在next()方法中会调用checkForComodification()方法,然后根据cursor的值获取到元素,接着将cursor的值赋给lastRet,并对cursor的值进行加1操作。初始时,cursor为0,lastRet为-1,那么调用一次之后,cursor的值为1,lastRet的值为0。注意此时,modCount为0,expectedModCount也为0。

      接着往下看,程序中判断当前元素的值是否为2,若为2,则调用list.remove()方法来删除该元素。

      我们看一下在ArrayList中的remove()方法做了什么:

    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 void fastRemove(int index) { modCount++; int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; // Let gc do its work
    }

    通过remove方法删除元素最终是调用的fastRemove()方法,在fastRemove()方法中,首先对modCount进行加1操作(因为对集合修改了一次),然后接下来就是删除元素的操作,最后将size进行减1操作,并将引用置为null以方便垃圾收集器进行回收工作。

      那么注意此时各个变量的值:对于iterator,其expectedModCount为0,cursor的值为1,lastRet的值为0。

      对于list,其modCount为1,size为0。

      接着看程序代码,执行完删除操作后,继续while循环,调用hasNext方法()判断,由于此时cursor为1,而size为0,那么返回true,所以继续执行while循环,然后继续调用iterator的next()方法:

      注意,此时要注意next()方法中的第一句:checkForComodification()。

      在checkForComodification方法中进行的操作是:

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

    如果modCount不等于expectedModCount,则抛出ConcurrentModificationException异常。

      很显然,此时modCount为1,而expectedModCount为0,因此程序就抛出了ConcurrentModificationException异常。

      到这里,想必大家应该明白为何上述代码会抛出ConcurrentModificationException异常了。

      关键点就在于:调用list.remove()方法导致modCount和expectedModCount的值不一致。

      注意,像使用for-each进行迭代实际上也会出现这种问题。

    二.在单线程环境下的解决办法

      既然知道原因了,那么如何解决呢?

      其实很简单,细心的朋友可能发现在Itr类中也给出了一个remove()方法:

     1 public void remove() {  2     if (lastRet == -1)  3     throw new IllegalStateException();  4  checkForComodification();  5  
     6     try {  7     AbstractList.this.remove(lastRet);  8     if (lastRet < cursor)  9         cursor--; 10     lastRet = -1; 11     expectedModCount = modCount; 12     } catch (IndexOutOfBoundsException e) { 13     throw new ConcurrentModificationException(); 14  } 15 }

    在这个方法中,删除元素实际上调用的就是list.remove()方法,但是它多了一个操作:

    expectedModCount = modCount;

    因此,在迭代器中如果要删除元素的话,需要调用Itr类的remove方法。

      将上述代码改为下面这样就不会报错了:

    public class Test { public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<Integer>(); list.add(2); Iterator<Integer> iterator = list.iterator(); while(iterator.hasNext()){ Integer integer = iterator.next(); if(integer==2) iterator.remove(); //注意这个地方
     } } }

    三.在多线程环境下的解决方法

      上面的解决办法在单线程环境下适用,但是在多线程下适用吗?看下面一个例子:

     1 public class Test {  2     static ArrayList<Integer> list = new ArrayList<Integer>();  3     public static void main(String[] args) {  4         list.add(1);  5         list.add(2);  6         list.add(3);  7         list.add(4);  8         list.add(5);  9         Thread thread1 = new Thread(){ 10             public void run() { 11                 Iterator<Integer> iterator = list.iterator(); 12                 while(iterator.hasNext()){ 13                     Integer integer = iterator.next(); 14  System.out.println(integer); 15                     try { 16                         Thread.sleep(100); 17                     } catch (InterruptedException e) { 18  e.printStackTrace(); 19  } 20  } 21  }; 22  }; 23         Thread thread2 = new Thread(){ 24             public void run() { 25                 Iterator<Integer> iterator = list.iterator(); 26                 while(iterator.hasNext()){ 27                     Integer integer = iterator.next(); 28                     if(integer==2) 29  iterator.remove(); 30  } 31  }; 32  }; 33  thread1.start(); 34  thread2.start(); 35  } 36 }

    运行结果:

      

      有可能有朋友说ArrayList是非线程安全的容器,换成Vector就没问题了,实际上换成Vector还是会出现这种错误。

      原因在于,虽然Vector的方法采用了synchronized进行了同步,但是由于Vector是继承的AbstarctList,因此通过Iterator来访问容器的话,事实上是不需要获取锁就可以访问。那么显然,由于使用iterator对容器进行访问不需要获取锁,在多线程中就会造成当一个线程删除了元素,由于modCount是AbstarctList的成员变量,因此可能会导致在其他线程中modCount和expectedModCount值不等。

      就比如上面的代码中,很显然iterator是线程私有的,

      初始时,线程1和线程2中的modCount、expectedModCount都为0,

      当线程2通过iterator.remove()删除元素时,会修改modCount值为1,并且会修改线程2中的expectedModCount的值为1,

      而此时线程1中的expectedModCount值为0,虽然modCount不是volatile变量,不保证线程1一定看得到线程2修改后的modCount的值,但是也有可能看得到线程2对modCount的修改,这样就有可能导致线程1中比较expectedModCount和modCount不等,而抛出异常。

      因此一般有2种解决办法:

      1)在使用iterator迭代的时候使用synchronized或者Lock进行同步;

      2)使用并发容器CopyOnWriteArrayList代替ArrayList和Vector。

      关于并发容器的内容将在下一篇文章中讲述。

      参考资料:

      http://blog.csdn.net/izard999/article/details/6708738

      http://www.2cto.com/kf/201403/286536.html

    哎...今天够累的,签到来了1...
    回复

    使用道具 举报

    您需要登录后才可以回帖 登录 | 立即注册

    本版积分规则

    QQ|手机版|小黑屋|Java自学者论坛 ( 声明:本站文章及资料整理自互联网,用于Java自学者交流学习使用,对资料版权不负任何法律责任,若有侵权请及时联系客服屏蔽删除 )

    GMT+8, 2021-9-19 16:25 , Processed in 0.061813 second(s), 29 queries .

    Powered by Discuz! X3.4

    Copyright © 2001-2020, Tencent Cloud.

    快速回复 返回顶部 返回列表