Java中的ConcurrentModificationException：深入解析与实战解决方案

2026-02-12 13:13:00 0条评论 3次阅读 0人点赞

在Java开发过程中，你是否遇到过这样的情况：当你正在遍历一个集合（比如ArrayList或HashMap），试图在遍历的同时删除某个元素时，程序突然崩溃，并抛出了一个名为 ConcurrentModificationException 的异常？这往往是新手开发者——甚至是有经验的开发者——常犯的一个错误。

在这篇文章中，我们将深入探讨这个异常背后的工作机制。我们将理解它为什么会产生，它与多线程并发的关系，以及如何在单线程和多线程环境下正确地解决它。我们将通过具体的代码示例来复现问题，分析原因，并最终掌握最佳的实践方案。

理解“快速失败”机制

要解决 ConcurrentModificationException，首先必须理解Java集合框架中的一个核心概念：快速失败迭代器。

“快速失败”是Java集合框架的一种错误检测机制。当这种迭代器创建后，除了迭代器自身的 INLINECODEa77a4566 或 INLINECODE3c66e808 方法外，如果以任何其他方式（比如直接调用集合的 INLINECODEd70eb6c4 方法）对底层数据结构进行了结构性的修改（添加或删除元素），迭代器就会立即“察觉”并抛出 INLINECODE26aba6d0。

这听起来可能有点严格，但它的设计目的是为了防止不可预测的行为和数据不一致。与其让程序在数据状态不确定的情况下继续运行产生难以排查的Bug，不如让它立即失败并报错。

#### 它是如何工作的？

实现这一机制的核心在于一个名为 modCount 的内部变量。

  • 计数器： 集合类内部维护了一个 modCount 变量，记录了集合被结构性修改（如添加、删除）的次数。
  • 快照： 当你创建一个迭代器时，迭代器会记录当前的 INLINECODE65cf90d0 值到一个名为 INLINECODE0d1f26f6 的变量中。
  • 检查： 每次调用迭代器的 INLINECODEcef47e53 方法时，它都会检查集合当前的 INLINECODE9052ba7e 是否等于初始化时的 expectedModCount。
  • 抛出异常： 如果这两个值不相等，说明在迭代器工作期间，集合被修改了，迭代器就会立即抛出 ConcurrentModificationException。

复现问题：单线程下的并发修改

虽然这个异常名字里包含“Concurrent”（并发），但它最常见的情况其实是发生在单线程中。这常常让初学者感到困惑。让我们先来看一个最典型的反面教材。

#### 示例 1：错误演示 —— 直接调用集合的 remove()

这是最常见的错误写法。我们在 INLINECODE69521f3e 循环中遍历列表，发现符合条件的元素后，直接调用 INLINECODE771ddece 来删除它。

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

public class FailFastExample {
    public static void main(String[] args) {
        // 创建一个整数列表
        ArrayList list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        // 获取迭代器
        Iterator iterator = list.iterator();

        while (iterator.hasNext()) {
            Integer value = iterator.next();
            System.out.println("当前元素: " + value);

            // 当值为 2 时，我们试图删除它
            if (value.equals(2)) {
                System.out.println("发现目标元素 2，准备直接从列表删除... ");
                
                // 错误所在：直接调用集合的 remove 方法
                // 这会改变 modCount，但迭代器的 expectedModCount 还是旧的
                list.remove(value); 
                
                System.out.println("删除操作完成");
            }
        }
        System.out.println("程序结束");
    }
}

控制台输出结果：

当前元素: 1
当前元素: 2
发现目标元素 2，准备直接从列表删除...
Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
    at java.util.ArrayList$Itr.next(ArrayList.java:859)
    at FailFastExample.main(FailFastExample.java:18)

为什么会报错？

当我们执行 INLINECODE157dc260 时，ArrayList 将内部的 INLINECODEfeba1800 加了1。然而，迭代器 INLINECODE2e76466b 并不知道这件事，它手里的 INLINECODEcdc31087 依然是创建时的值。当循环回到 INLINECODE3beea007 顶部再次调用 INLINECODEd4416cdd 时，检查机制发现 modCount != expectedModCount，于是抛出了异常。

解决方案 1：使用迭代器的 remove() 方法

最标准的解决单线程下删除元素问题的方法，是使用迭代器提供的 remove() 方法。

#### 示例 2：正确做法 —— 迭代器的 remove()

INLINECODE457b1c4b 方法会在删除元素后，同步更新迭代器内部的 INLINECODE479aea25，从而保持一致性。

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

public class CorrectIteratorExample {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        Iterator iterator = list.iterator();

        while (iterator.hasNext()) {
            Integer value = iterator.next();
            System.out.println("当前元素: " + value);

            if (value.equals(2)) {
                System.out.println("发现目标元素 2，准备使用迭代器删除...");
                
                // 正确所在：调用迭代器的 remove 方法
                // 这会同步更新 expectedModCount
                iterator.remove();
                
                System.out.println("删除成功。注意：每次 iterator.next() 后只能调用一次 iterator.remove()");
            }
        }
        
        // 验证结果
        System.out.println("最终列表内容: " + list);
    }
}

输出结果：

当前元素: 1
当前元素: 2
发现目标元素 2，准备使用迭代器删除...
删除成功。注意：每次 iterator.next() 后只能调用一次 iterator.remove()
当前元素: 3
当前元素: 4
当前元素: 5
最终列表内容: [1, 3, 4, 5]

解决方案 2：Java 8+ 的优雅写法

如果你使用的是 Java 8 或更高版本，代码可以写得更简洁、更安全。我们可以使用 Collection.removeIf() 方法，或者流式操作。

#### 示例 3：使用 removeIf()

这是目前最推荐的写法，因为它内部已经处理好了迭代逻辑，代码可读性极高。

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

public class RemoveIfExample {
    public static void main(String[] args) {
        List list = new ArrayList(Arrays.asList(1, 2, 3, 4, 5, 2, 6));

        System.out.println("原始列表: " + list);

        // 一行代码搞定：删除所有值为 2 的元素
        // Predicate（谓词）决定是否保留元素，返回 true 则移除
        list.removeIf(element -> element.equals(2));

        System.out.println("删除 2 之后的列表: " + list);
    }
}

解决方案 3：安全的循环方式

除了迭代器，传统的 for 循环在倒序遍历时也可以安全删除，但需要小心索引管理。

#### 示例 4：倒序 for 循环

当我们从后向前遍历时，删除元素不会影响未遍历部分的索引。这是一种很古老但有效的技巧。

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

public class ReverseForLoopExample {
    public static void main(String[] args) {
        List list = new ArrayList(Arrays.asList(1, 2, 3, 4, 5));

        System.out.println("开始倒序遍历...");

        // 倒序遍历：从 size-1 开始，到 0 结束
        for (int i = list.size() - 1; i >= 0; i--) {
            Integer value = list.get(i);
            if (value.equals(2)) {
                System.out.println("在索引 " + i + " 处发现 2，正在移除...");
                list.remove(i); // 这里是安全的，因为修改不会影响前面的索引
            }
        }
        
        System.out.println("最终列表: " + list);
    }
}

常见误区与陷阱

在处理这个问题时，还有一些常见的陷阱值得我们注意。

#### 陷阱 1：使用 for-each 循环

很多人会尝试使用 for-each 循环来遍历，这本质上是使用迭代器实现的，因此也会抛出异常。

// 错误示例：
for (Integer value : list) {
    if (value.equals(2)) {
        list.remove(value); // 抛出 ConcurrentModificationException
    }
}

#### 陷阱 2：只删除第一个元素时“碰巧”成功

有时候你可能会发现，如果你删除列表中的倒数第二个元素，程序竟然没有报错！

例如，列表有 INLINECODEbe289166。当你遍历到 INLINECODE933a4c5c 并删除它，列表变为 INLINECODE43422a53。此时循环指针已经移到了末尾，下一次 INLINECODEe7a4c48f 检查发现没有更多元素，循环自然结束，next() 方法没有被再次调用，检查机制也就没有触发。

千万不要依赖这种行为！ 这是极其危险的。代码逻辑稍微一变（比如删除的是中间元素），Bug就会出现。

多线程环境下的并发修改

虽然我们前面主要讨论了单线程的情况，但在多线程环境下，这个问题会变得更加复杂和真实。

#### 场景

线程 A 正在使用迭代器遍历列表，而线程 B 同时修改了这个列表（添加或删除元素）。

#### 解决方案

对于多线程环境，单靠 iterator.remove() 是不够的。我们需要线程安全的措施。

  • 使用 Collections.synchronizedList()：

包装原始列表，但在遍历时，必须使用 synchronized 块锁住列表对象。

  • 使用 CopyOnWriteArrayList：

这是并发包 java.util.concurrent 下的类。正如其名，当你修改它时，它会复制一份底层数组。因此，迭代器遍历的是创建时的旧数组快照，不会被新操作干扰。这允许你在遍历的同时进行修改而不抛出异常，但代价是内存开销和性能损耗。

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

public class MultiThreadExample {
    public static void main(String[] args) {
        // 使用线程安全的 CopyOnWriteArrayList
        List safeList = new CopyOnWriteArrayList();
        safeList.add(1);
        safeList.add(2);
        safeList.add(3);

        // 线程 1：遍历
        Thread thread1 = new Thread(() -> {
            Iterator it = safeList.iterator();
            while (it.hasNext()) {
                System.out.println("线程1 读取: " + it.next());
                try { Thread.sleep(100); } catch (InterruptedException e) {}
            }
        });

        // 线程 2：修改
        Thread thread2 = new Thread(() -> {
            try { Thread.sleep(50); } catch (InterruptedException e) {}
            System.out.println("线程2 尝试删除元素...");
            safeList.remove(1);
        });

        thread1.start();
        thread2.start();
    }
}

总结与最佳实践

现在我们已经深入了解了 ConcurrentModificationException 的来龙去脉。让我们总结一下如何在实际开发中应对这个问题。

  • 优先选择 INLINECODE57b60c5d： 如果你的项目使用 Java 8+，且是在单线程环境下处理，INLINECODEba64db1d 是最简洁、最安全的选择。
  • 使用迭代器进行删除： 如果必须手动控制遍历逻辑，请使用 INLINECODE82adae31，并确保调用 INLINECODE55ce6e57 而不是 collection.remove()。
  • 避免在 for-each 循环中修改集合： for-each 语法糖掩盖了迭代器的本质，容易引发错误，不要在这种循环中进行结构性修改。
  • 多线程环境注意同步： 如果涉及多线程，请考虑使用 INLINECODEcbabea2b 或使用 INLINECODE1a0af444 关键字加锁，不要盲目依赖快速失败机制来处理并发问题，因为那只是为了防止数据不一致，而不是为了解决并发冲突。
  • 理解“结构性修改”： 并不是所有操作都会导致异常。比如修改 ArrayList 中某个已存在元素的值（INLINECODE2338f7e2 方法）通常不会导致 INLINECODE6a4e2634 变化，因此是安全的。添加或删除元素则属于结构性修改，会触发异常。

掌握这些细节，不仅能帮助你避免令人沮丧的调试时间，还能让你写出更加健壮、高效的代码。希望这篇文章能帮助你彻底搞定 Java 中的这个常见异常！

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。如需转载，请注明文章出处豆丁博客和来源网址。https://shluqu.cn/43784.html
点赞
0.00 平均评分 (0% 分数) - 0 票

相关文章美国1G带宽/1T流量高速vps $17.99/年