java.util.ConcurrentModificationException异常解决和分析

曾经终败给现在 2024-04-17 17:01 46阅读 0赞

## 一、异常再现及解决方案 ##

在遍历ArrayList并对其进行删除操作时，跳出**java.util.ConcurrentModificationException异常**，先上错误代码：

@Test
        public void test1() {
            List<String> list = new ArrayList<String>();
            list.add("小白");
            list.add("小紫");
            list.add("小红");
            list.add("小绿");
            list.add("小兰");
            for (String str : list) {
                if(str.equals("小紫")){
                    list.remove(str);
                }
            }
        }
    
        @Test
        public void test2() {
            List<String> list = new ArrayList<String>();
            list.add("小白");
            list.add("小紫");
            list.add("小红");
            list.add("小绿");
            list.add("小兰");
            Iterator<String> it = list.iterator();
            while(it.hasNext()){
                String x = it.next();
                if(x.equals("小紫")){
                    list.remove(x);
                }
            }
        }

我出现的是test1的问题，还有一种就是test2也会有这样的问题。

其实不只是遍历ArrayList会出现 **ConcurrentModificationException** 异常，只要是集合 Collection 的子类都会出现这个问题。

正确的用法如下：

@Test
        public void test6() {
            List<String> list = new ArrayList<String>();
            list.add("小白");
            list.add("小紫");
            list.add("小红");
            list.add("小绿");
            list.add("小兰");
            Iterator<String> it = list.iterator();
            while(it.hasNext()){
                String x = it.next();
                if(x.equals("小紫")){
                    it.remove();
                }
            }
        }

循环要用iterator.hasNext()；删除元素不能用集合的remove()，而要用迭代器iterator的remove。注意好这两点就不会报 ConcurrentModificationException异常啦！

## 二、ConcurrentModificationException异常分析 ##

**1、test1 分析**

test1使用的是foreach遍历（增强for循环），进入源码中看它的实现如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70][]

我们可以看到，他抛出异常的是因为 **modCount != expectedModCount** ，那么需要先弄清楚这两个参数是什么。

**modCount** 该参数继承自抽象类AbstractList，在AbstractList中对他的解释如下，直译第一句：结构被修改的次数。也就是ArrayList这个对象被修改的次数。**expectedModCount**，顾名思义，期望被修改的次数，主要是循环 遍历时用来临时保存modCount的参数，防止对象还在循环遍历的时候被突然修改而导致遍历出错的情况。当遍历过程中出现了unexpectedly（出乎意料地）的操作时，按照 fail-fast （快速失败）原则便会立刻停止并报出 ConcurrentModificationException异常。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 1][]

回到案例分析，在ArrayList执行add和remove操作时（remove方法中会调用fastRemove方法），都会执行modCount++的自增。

![20210706110517781.png][]![20210706110608404.png][]

于是乎，在 test1 的案例中add了五个小盆友，所以此时 modCount==5。接下来的foreach遍历操作将 modCount 赋值给了 expectedModCount ，所以它也是5。test1 中循环到‘小紫’的时候我执行了remove操作，因此 modCount 自增变成了6。这时modCount 跟 expectedModCount 就不相等了，于是便报出 ConcurrentModificationException异常。

**2、test2 分析**

两个案例出错的原理差不多。同样看源码，it.next()的实现源码如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 2][]

在 next 中首先会执行 checkForComodification() 方法，去判断 modCount 和 expectedModCount是否相等，不相等就报 ConcurrentModificationException异常。

![20210706120133451.png][]

同理，在 test2 中由于循环时进行了 remove 操作，导致 modCount 自增，modCount != expectedModCount，所以就报出了 ConcurrentModificationException异常。

**3、正确用法分析**

正确用法中，主要是使用了 Iterator 迭代器的 remove 方法。

**原理（[来源][Link 1]）：**

**Iterator 是工作在一个独立的线程中，并且拥有一个 mutex 锁。   
Iterator 被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变。当索引指针往后移动的时候就找不到要迭代的对象，按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。**

**所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象， Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。**

解释一下就是 Iterator.remove() 方法中多了一个 expectedModCount=modCount，维护了索引的一致性，所以它就不会报 ConcurrentModificationException异常。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 3][]

## 三、拓展 ##

上面提到的问题和分析都是在单线程的情况下的，接下来讲讲多线程下出现异常的情况，虽然我还没遇到，但既然学到了就将它记录下来，方便日后复习。

### **1、问题再现** ###

public static void main(String[] args) {
            test1();
        }
    
        private static void test1() {
            final List<String> list = new ArrayList<String>();
            list.add("小白");
            list.add("小紫");
            list.add("小红");
            list.add("小绿");
            list.add("小兰");
    
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    Iterator<String> it = list.iterator();
                    while (it.hasNext()) {
                        String str = it.next();
                        System.out.println("Thread1 --- " + str);
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    Iterator<String> it = list.iterator();
                    while (it.hasNext()) {
                        String str = it.next();
                        if (str.equals("小紫")) {
                            it.remove();
                        }else {
                            System.out.println("Thread2 --- " + str);
                        }
                    }
                }
            });
            thread1.start();
            thread2.start();
             
        }

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 4][]

案例中主要开启了两个线程，线程1是延时遍历，线程2是遍历+删除操作，注意用的都是同一个 list 集合。结果我们可以看到 thread1 遍历了第一个后进入了 sleep 休眠状态，此时 thread2 开始遍历并送走了‘小紫’（remove后modCount +1），遍历完成后， thread1 休眠完毕，准备遍历第二个元素‘小紫’，但此时小紫已被移除，同时modCount != expectedModCount，所以就会报ConcurrentModificationException异常。结合表格看可能会更清晰：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="vertical-align:middle;">时间点</td> 
   <td style="vertical-align:middle;">arrayList.modCount</td> 
   <td style="vertical-align:middle;">thread1 iterator.expectedModCount</td> 
   <td style="vertical-align:middle;">thread2 iterator.expectedModCount</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:middle;">thread start，初始化iterator</td> 
   <td style="vertical-align:middle;">5</td> 
   <td style="vertical-align:middle;">5</td> 
   <td style="vertical-align:middle;">5</td> 
  </tr> 
  <tr> 
   <td style="vertical-align:middle;">thread2.remove()调用之后</td> 
   <td style="vertical-align:middle;">6</td> 
   <td style="vertical-align:middle;">5</td> 
   <td style="vertical-align:middle;">6</td> 
  </tr> 
 </tbody> 
</table>

两个线程都有各自创建的 Iterator 迭代器，一个线程 remove 后 expectedModCount 被重新赋值，另一个线程的 expectedModCount 是无法了解并同步的，所以 remove 操作后 thread1 的expectedModCount 依然是5，跟 modCount 自然就不相等了。

### 2、解决方案 ###

**（1）方案一：线程加锁**

给每个线程加同步锁，就是在遍历前将 list 锁住，仅执行当前线程的循环遍历操作，其他线程等待。本质上和单线程类似，优点就是不会报异常，缺点就是多变单，效率降低了。

public static void main(String[] args) {
            test1();
        }
    
        private static void test1() {
            final List<String> list = new ArrayList<String>();
            list.add("小白");
            list.add("小紫");
            list.add("小红");
            list.add("小绿");
            list.add("小兰");
    
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (list) {
                        Iterator<String> it = list.iterator();
                        while (it.hasNext()) {
                            String str = it.next();
                            System.out.println("Thread1 --- " + str);
                            try {
                                Thread.sleep(1);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (list) {
                        Iterator<String> it = list.iterator();
                        while (it.hasNext()) {
                            String str = it.next();
                            if (str.equals("小紫")) {
                                it.remove();
                            }else {
                                System.out.println("Thread2 --- " + str);
                            }
                        }
                    }
                }
            });
            thread1.start();
            thread2.start();
             
        }

**（2）方案二：使用CopyOnWriteArrayList**

public static void main(String[] args) {
            test1();
        }
    
        private static void test1() {
            final List<String> list = new CopyOnWriteArrayList<String>();
            list.add("小白");
            list.add("小紫");
            list.add("小红");
            list.add("小绿");
            list.add("小兰");
    
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    Iterator<String> it = list.iterator();
                    while (it.hasNext()) {
                        String str = it.next();
                        System.out.println("Thread1 --- " + str);
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    Iterator<String> it = list.iterator();
                    while (it.hasNext()) {
                        String str = it.next();
                        if (str.equals("小紫")) {
                            list.remove("小紫");
                        }else {
                            System.out.println("Thread2 --- " + str);
                        }
                    }
                }
            });
            thread1.start();
            thread2.start();
             
        }

运行结果：

![20210707112842550.png][]

可以看到，thread2 已经 remove 了小紫，thread1 仍然能遍历出来，并且没报错。原因的话继续从源码中找，直接看下 CopyOnWriteArrayList 的源码。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 5][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 6][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 7][]

可以看到，在初始化迭代器的时候，list 对象其实已经被复制保存在 **private final Object\[\] snapshot;** 这个临时对象里面，接下来的遍历用的都是这个保存复制的对象。所以 thread1 和 thread2 在初始化 Iterator 迭代器时，各自复制保存了 list 对象，操作便互不相干。即使在 thread2 中 remove 掉了“小紫”，thread1 中用的是已经复制保存好的不会受到影响，也就能打印出“小紫”了。

<table style="width:633px;"> 
 <tbody> 
  <tr> 
   <td style="width:132px;">时间点</td> 
   <td style="width:208px;">CopyOnWriteArrayList对象</td> 
   <td style="width:114px;">thread1</td> 
   <td style="width:179px;">thread2</td> 
  </tr> 
  <tr> 
   <td style="width:132px;">thread.start()</td> 
   <td style="width:208px;">A</td> 
   <td style="width:114px;">Copy-A1</td> 
   <td style="width:179px;">Copy-A2</td> 
  </tr> 
  <tr> 
   <td style="width:132px;">thread2.remove后</td> 
   <td style="width:208px;">B</td> 
   <td style="width:114px;">Copy-A1</td> 
   <td style="width:179px;">B</td> 
  </tr> 
 </tbody> 
</table>

结合表格看可能会好理解些，thread2 使用copy-A在 remove 操作后，会通过 setArray 将修改过后的对象B，赋值回给原来的 array 对象。

![20210707144032793.png][]

使用 CopyOnWriteArrayList 有几个需要注意的地方。

1、从 CopyOnWriteArrayList 的源码可以看到，CopyOnWriteArrayList 创建的 Iterator 迭代器是不能 remove、set 和 add 操作的，否则会 **throw new UnsupportedOperationException();** 提示你不支持此操作。

但是呢，是可以用 CopyOnWriteArrayList 自带的 remove 操作的，所以我在案例中没有用迭代器的 remove，用的是 list 自带的 remove。不会报错是因为他每次 remove 操作后会将修改后的array 对象重新赋值给 expectedArray ，这样在遍历下一个时 checkForComodification() 就不会报错了。跟上面的原理差不多，只是这里 modCount 直接换成了 array 对象。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 8][]

![20210707171518413.png][]

2、 第二点需要注意的是，thread2对array数组的修改thread1并不能被动感知到，只能通过hashCode()方法去主动感知。

3、最后一点是效率问题，可以看到整个过程 array 对象拷贝来拷贝去的，每次修改还需要重新 new 一个 array 对象，这样看效率自然就降低了。

### 参考文章 ###

[https://www.cnblogs.com/zhuyeshen/p/10956820.html][https_www.cnblogs.com_zhuyeshen_p_10956820.html]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 9][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/a8908a1cc3bd459894607131db115360.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/cc71a77329bb4fc3ab90fb671e34932e.png
[20210706110517781.png]: https://img-blog.csdnimg.cn/20210706110517781.png
[20210706110608404.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/6bdc26c51bca4f86bd021c35b07c4b55.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/e6cac85cebf1444696801972cdd8f81e.png
[20210706120133451.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/8c66e119b3a64ac98a83262413b37e0d.png
[Link 1]: https://www.iteye.com/blog/lz12366-675016
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/9b3908d28fcb428096a53b3a29440719.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/5463e451bbc2408c95db979f51f78a58.png
[20210707112842550.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/11eb201ffc1a4f8b90d986fb20b17102.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/0d4e2aefed8e4eb083c70498891eacf2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/f02b1a3bdec04bffb7784cc7d9bf8b0d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/bb6281afa1274d6b977174d93a82139a.png
[20210707144032793.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/86e9b2f691184c6eab3f12fb94b40f61.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/57980fbb753243c2815c76ca84112f12.png
[20210707171518413.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/f22f188a560f4f54aaa6820e729d0578.png
[https_www.cnblogs.com_zhuyeshen_p_10956820.html]: https://www.cnblogs.com/zhuyeshen/p/10956820.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Fsb25lX2luXw_size_16_color_FFFFFF_t_70 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/30802ab9539046eabe760ba46cc2769d.jpg