深入理解 Java 中的 ConcurrentModificationException 及其解决方案

最新推荐文章于 2025-05-12 23:30:29 发布
最新推荐文章于 2025-05-12 23:30:29 发布
阅读量1.3k 收藏 12
点赞数 10
CC 4.0 BY-SA版权
分类专栏： JAVA 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_69174823/article/details/144451190

目录

前言

一、ConcurrentModificationException 的基本概念

1. 定义

2. 什么是结构性修改？

二、ConcurrentModificationException 的触发场景

1. 单线程环境中的触发

2. 多线程环境中的触发

三、ConcurrentModificationException 的底层原理

四、解决 ConcurrentModificationException 的方法

方法 1：使用 Iterator 的 remove() 方法

方法 2：使用 CopyOnWriteArrayList

方法 3：使用普通的 for 循环

方法 4：使用 Synchronized 同步块

五、总结

前言

在 Java 的日常开发中，ConcurrentModificationException （并发修改异常）是一个常见的异常，尤其是在操作集合（如 List、Map 等）时。如果对集合进行迭代的同时又修改了集合，就有可能抛出这个异常。本文将对 ConcurrentModificationException 进行深入剖析，了解其产生的原因，以及解决该异常的多种方式。

一、ConcurrentModificationException 的基本概念

1. 定义

ConcurrentModificationException 是 Java 中的运行时异常，位于包 java.util 下。它表示当一个线程对集合进行迭代的过程中，同时检测到另一个线程或同一线程对该集合进行了结构性修改时抛出的异常。

2. 什么是结构性修改？

结构性修改是指改变集合的结构，例如：

  • 添加元素
  • 删除元素
  • 清空集合

非结构性修改（如通过 set() 方法替换列表中的某个值）通常不会触发此异常，因为它不会改变集合的结构。

二、ConcurrentModificationException 的触发场景

1. 单线程环境中的触发

即使在单线程环境中，如果在迭代集合时直接对集合进行增删操作，也会抛出该异常。例如：

import java.util.ArrayList;
import java.util.List;

public class SingleThreadExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        for (String item : list) {
            if ("A".equals(item)) {
                list.remove(item); // 在迭代时修改集合
            }
        }
    }
}


//输出
Exception in thread "main" java.util.ConcurrentModificationException

原因：for-each 循环底层使用了 Iterator。当通过 Iterator 遍历集合时，直接对集合进行修改会触发 modCount 不一致，从而抛出异常。

2. 多线程环境中的触发

在多线程环境下，一个线程正在遍历集合，而另一个线程对集合进行修改，也可能抛出该异常。例如：

import java.util.ArrayList;
import java.util.List;

public class MultiThreadExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        new Thread(() -> {
            for (String item : list) {
                System.out.println(item);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(() -> {
            try {
                Thread.sleep(20);
                list.add("D"); // 修改集合
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

输出：可能会抛出 ConcurrentModificationException

原因：两个线程同时操作集合，导致迭代器检测到集合的 modCount 被改变。

三、ConcurrentModificationException 的底层原理

在 Java 集合（如 ArrayList、HashMap）中，迭代器会维护一个 modCount 变量来跟踪集合的修改次数。当迭代器创建时，它会保存当前的 modCount 值。在迭代过程中，每次调用 next() 方法时，迭代器会检查集合当前的 modCount 是否与初始值一致。如果不一致，就说明集合被修改过，于是抛出 ConcurrentModificationException。

modCount 的核心代码示例如下（以 ArrayList 为例）：

public class ArrayList<E> extends AbstractList<E> {
    protected transient int modCount = 0; // 修改计数

    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }

    public E remove(int index) {
        modCount++; // 每次结构性修改都会增加 modCount
        E oldValue = elementData(index);
        fastRemove(index);
        return oldValue;
    }
}

在 Iterator 中的检查逻辑：

public E next() {
    if (modCount != expectedModCount) // 检查是否有不一致
        throw new ConcurrentModificationException();
    return (E) ArrayList.this.elementData(cursor++);
}

四、解决 ConcurrentModificationException 的方法

方法 1：使用 Iterator 的 remove() 方法

如果需要在迭代时修改集合，可以使用 Iterator 提供的 remove() 方法，而不是直接调用集合的 remove() 方法。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorRemoveExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            if ("A".equals(item)) {
                iterator.remove(); // 正确的删除方式
            }
        }

        System.out.println(list); // 输出：[B, C]
    }
}
方法 2：使用 CopyOnWriteArrayList

在多线程环境中，使用 CopyOnWriteArrayList 替代普通的 ArrayList。CopyOnWriteArrayList 是线程安全的，它在每次修改时都会创建集合的副本，从而避免 ConcurrentModificationException。

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListExample {
    public static void main(String[] args) {
        List<String> list = new CopyOnWriteArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        for (String item : list) {
            if ("A".equals(item)) {
                list.remove(item); // 不会抛出 ConcurrentModificationException
            }
        }

        System.out.println(list); // 输出：[B, C]
    }
}

注意：CopyOnWriteArrayList 在修改性能上较差，适用于读多写少的场景。

方法 3：使用普通的 for 循环

普通的 for 循环可以直接操作集合，不会触发迭代器的 modCount 检查。

import java.util.ArrayList;
import java.util.List;

public class ForLoopExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        for (int i = 0; i < list.size(); i++) {
            if ("A".equals(list.get(i))) {
                list.remove(i); // 直接删除
                i--; // 删除后需要调整索引
            }
        }

        System.out.println(list); // 输出：[B, C]
    }
}
方法 4：使用 Synchronized 同步块

在多线程环境中，可以使用同步块对集合进行显式加锁，从而避免其他线程同时修改集合。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SynchronizedExample {
    public static void main(String[] args) {
        List<String> list = Collections.synchronizedList(new ArrayList<>());
        list.add("A");
        list.add("B");
        list.add("C");

        synchronized (list) { // 显式加锁
            for (String item : list) {
                if ("A".equals(item)) {
                    list.remove(item);
                }
            }
        }

        System.out.println(list); // 输出：[B, C]
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SynchronizedExample {
    public static void main(String[] args) {
        List<String> list = Collections.synchronizedList(new ArrayList<>());
        list.add("A");
        list.add("B");
        list.add("C");

        synchronized (list) { // 显式加锁
            for (String item : list) {
                if ("A".equals(item)) {
                    list.remove(item);
                }
            }
        }

        System.out.println(list); // 输出：[B, C]
    }
}

五、总结

ConcurrentModificationException (并发修改异常) 的出现通常是因为在迭代集合时同时修改了集合。要避免该异常，应该根据具体场景选择合适的解决方案：

  • 在单线程环境下，使用迭代器的 remove() 方法。
  • 在多线程环境下，使用线程安全的集合如 CopyOnWriteArrayList 或对集合加锁。
  • 对于简单场景，可以使用普通的 for 循环。

        通过合理的方式处理集合的修改，不仅能避免异常，还能提升程序的稳定性和可维护性。希望本文能帮助您深入理解 ConcurrentModificationException 及其解决方案。如有任何疑问，欢迎交流！

深入理解Java中HashMap的modCount机制
fudaihb的博客
04-26 1038
我们将深入探讨`HashMap`的内部工作机制，特别是`modCount`的角色。我们将了解它是如何帮助`HashMap`实现迭代器的快速失败机制、跟踪结构修改次数，并确保数据的一致性和完整性的。通过对`modCount`的深入理解，我们可以更好地掌握`HashMap`的使用和优化，同时避免在实际应用中可能遇到的一些问题和陷阱。
Java—— ConcurrentModificationException（并发修改异常）
m0_65302201的博客
09-28 2579
Java—— ConcurrentModificationException（并发修改异常）
Java ConcurrentModificationException异常原因和解决方法
starsliu
03-09 298
原文出处： 海子 在前面一篇文章中提到，对Vector、ArrayList在迭代的时候如果同时对其进行修改就会抛出java.util.ConcurrentModificationException异常。下面我们就来讨论以下这个异常出现的原因以及解决办法。 以下是本文目录大纲： 一.ConcurrentModificationException异常出现的原因 二.在单线程环境
如何避免Java中的ConcurrentModificationException
最新发布
zwh1zwh的博客
05-12 540
是一种运行时异常，表示在并发环境下，某个线程在遍历集合时，另一个线程修改了集合的结构。然而，​即使是在单线程环境中，也可能触发此异常，例如在遍历过程中直接调用remove()方法。// 抛出ConcurrentModificationException的根源在于集合的结构修改与遍历操作的不一致。理解集合的底层实现（如modCount机制）是解决问题的关键。根据具体场景选择迭代器操作、并发集合或Java 8+的新特性，可以高效避免此类异常。​最佳实践​：在单线程中优先使用迭代器的remove()
【Java】解决Java报错：ConcurrentModificationException
Easonmax的博客
06-07 1682
理解并有效处理对于编写健壮的Java程序至关重要。通过本文提供的解决方案和预防措施，开发者可以有效避免和解决这类异常，提高代码质量和可靠性。希望本文能帮助你更好地理解和处理并发修改问题，从而编写出更加可靠的Java应用程序。
ConcurrentModificationException异常原因，解决方法，线程安全的单例模式
Rose J 的博客
02-03 7100
ConcurrentModificationException（并发修改异常）是基于java集合中的 快速失败（fail-fast） 机制产生的，在使用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的内容进行了增删改，就会抛出该异常。快速失败机制使得java的集合类不能在多线程下并发修改，也不能在迭代过程中被修改。在线程安全的几种单例中。
ArrayList引起的ConcurrentModificationException 异常原因及解决方法
lhl6688的专栏
02-27 4015
ArrayList引起的ConcurrentModificationException 异常原因及解决方法
Java常见错误与解决方案精析
从给定的文件信息来看，这里包含了一套关于Java语言常见错误及其解决方案的学习资料。文件中提到的内容涵盖了一百个在Java开发过程中可能遇到的问题实例及其相应的解决方法。接下来，我将详细解释在Java开发过程中...
Java编程中的30个常见异常及解决方案解析
总的来说，尽管本文提供了一个异常处理的概览，但每个异常的详细分析和解决方案需要读者进一步查阅相关资料和实际的源码来获得深入理解。而作为IT行业专家，我们应当持续关注Java语言的最新发展和最佳实践，以保持...
【Java集合框架异常处理秘籍】：ConcurrentModificationException的解决之道
[【Java集合框架异常处理秘籍】：ConcurrentModificationException的解决之道](https://programming.vip/images/doc/e15999f2954ff776f47b260ad8055be1.jpg) # 1. ConcurrentModificationException概述 在多线程...
【深入理解Java List】：底层数据结构及优化技巧
[【深入理解Java List】：底层数据结构及优化技巧](https://media.geeksforgeeks.org/wp-content/uploads/20211118124320/removeLinedkList.jpg) # 1. Java List接口概述 Java List接口是Java集合框架中的一个核心...
ConcurrentModificationException
weixin_30497527的博客
06-13 134
ConcurrentModificationException 在对集合类进行操作时，有很多清空会出现ConcurrentModificationException。这里我们来分不同的遍历方式和线程场景下来讨论ConcurrentModificationException产生的原因和解决的方法。下面我们先就使用迭代器出现异常来进行讨论，最后再讨论其他的遍历形式。 Iterator 使用 Itera...
java.util.ConcurrentModificationException
java的涟漪
06-04 992
原代码如下： for (PKer pkerOnDesk : desk.getPkers()){desk.getPkers().remove(pkerOnDesk); }原因： jdk5.0以上的for-each也是利用内部的iterator来遍历集合的（跟以前的iterator一样） 获得的Iterator是一个内部类产生的迭代器，这个迭代器在调用next方法时，会检查列表是否被修改过，如
Java— ConcurrentModificationException异常处理
qq_44375810的博客
06-22 290
异常描述： 如果一个迭代器发现它的集合被另一个迭代器修改了，或是被该集合自身的方法修改了，就会跑出一个ConcurrentModificationException异常。 （也存在例外情况，文末已给出） 例： 情况一： 情况二： 避免该异常应遵循原则： 可以根据需要为一个集合关联多个迭代器，前提是这些迭代器只能读取集合。或者，可以关联一个能同时读写的迭代器。 对上述例子可以修改为： 修改一： 修改二（和原例的需求不符合，目的为演示上述避免异常的原则）： 例外： 链表只跟踪对列表的结构性修改，例如，添
【Java】已解决java.util.ConcurrentModificationException异常
屿小夏.的知识博客
06-19 1777
考虑使用并发集合：如果你的应用程序需要处理多线程并发修改集合的情况，考虑使用java.util.concurrent包下的并发集合，如CopyOnWriteArrayList、ConcurrentHashMap等。要正确地在迭代过程中修改集合，可以使用迭代器的remove方法，或者在单线程环境中使用Java 8引入的removeIf方法（如果集合是Collection的某个实现了该方法的子类，如ArrayList）。多线程并发修改：当一个线程正在迭代集合时，另一个线程尝试修改集合的大小或内容。
ConcurrentModificationException异常
热门推荐
小礼貌的博客
10-16 9万+
一：ConcurrentModificationException异常： 当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。 二：遍历list集合时删除元素出现的异常 public static void main(String[] args) { ArrayList&lt;String&gt; list=new ArrayList&lt;String&gt;(); ...
Java concurrentModificationException
scuwangjianfei
03-28 733
package concurrent;import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;/* * @author: wj
JAVA ConcurrentModificationException
回眸^_^已劃句點
08-16 112
import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.ListIterator; /* * 问题? * 我有一个集合，如下，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。 * * ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值