【Java】解决Java报错：ConcurrentModificationException

Easonmax2024-06-08 23:50

文章目录

      • 引言
      • [1. 错误详解](#1. 错误详解)
      • [2. 常见的出错场景](#2. 常见的出错场景)
        • [2.1 遍历过程中修改集合](#2.1 遍历过程中修改集合)
        • [2.2 使用 `Iterator` 进行删除操作](#2.2 使用 Iterator 进行删除操作)
      • [3. 解决方案](#3. 解决方案)
        • [3.1 使用 `Iterator` 的 `remove` 方法](#3.1 使用 Iterator 的 remove 方法)
        • [3.2 使用 `CopyOnWriteArrayList`](#3.2 使用 CopyOnWriteArrayList)
        • [3.3 使用 `synchronized` 块](#3.3 使用 synchronized 块)
      • [4. 预防措施](#4. 预防措施)
        • [4.1 使用线程安全的集合类](#4.1 使用线程安全的集合类)
        • [4.2 使用合适的遍历和修改方法](#4.2 使用合适的遍历和修改方法)
        • [4.3 单元测试](#4.3 单元测试)
      • 结语

引言

在Java编程中，ConcurrentModificationException 是一种常见的运行时异常，通常发生在对集合进行遍历时，另一个线程试图修改该集合。这类错误提示为："ConcurrentModificationException: Collection modified during iteration"，意味着在遍历集合的过程中，集合被并发地修改了。本文将详细探讨ConcurrentModificationException的成因、解决方案以及预防措施，帮助开发者理解和避免此类问题，从而提高代码的健壮性和可靠性。

1. 错误详解

ConcurrentModificationException 是一种由 Java 运行时环境抛出的异常，表示在遍历集合时，该集合被其他线程或操作并发修改。这通常发生在使用 Iterator 或增强型 for 循环遍历集合时，对集合进行修改操作（如添加或删除元素）。

2. 常见的出错场景

2.1 遍历过程中修改集合

最常见的情况是在使用 Iterator 或增强型 for 循环遍历集合时，直接对集合进行修改。

java 复制代码 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {
    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 (item.equals("B")) {
                list.remove(item);  // 尝试在遍历时修改集合，将抛出ConcurrentModificationException
            }
        }
    }
}
2.2 使用 Iterator 进行删除操作

直接使用 Iterator 的 remove 方法可以避免 ConcurrentModificationException，但如果在遍历过程中不使用 Iterator 的方法，而是直接使用集合的 remove 方法，也会引发该异常。

java 复制代码 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {
    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 (item.equals("B")) {
                list.remove(item);  // 使用集合的remove方法，而不是iterator的remove方法，将抛出ConcurrentModificationException
            }
        }
    }
}

3. 解决方案

解决ConcurrentModificationException的关键在于确保在遍历集合时，避免直接对集合进行修改，或者使用线程安全的集合类和方法。

3.1 使用 Iterator 的 remove 方法

正确地使用 Iterator 的 remove 方法可以避免 ConcurrentModificationException。

java 复制代码 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {
    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 (item.equals("B")) {
                iterator.remove();  // 正确使用iterator的remove方法
            }
        }

        System.out.println(list);  // 输出：[A, C]
    }
}
3.2 使用 CopyOnWriteArrayList

如果集合在遍历过程中需要频繁修改，可以使用线程安全的 CopyOnWriteArrayList，它在每次修改时都会创建集合的副本，避免并发修改问题。

java 复制代码 
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class Main {
    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 (item.equals("B")) {
                list.remove(item);  // 使用CopyOnWriteArrayList，安全地进行修改
            }
        }

        System.out.println(list);  // 输出：[A, C]
    }
}
3.3 使用 synchronized 块

在多线程环境中，可以使用 synchronized 块来同步对集合的访问，确保在遍历时不会被其他线程修改。

java 复制代码 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

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

        synchronized (list) {
            Iterator<String> iterator = list.iterator();
            while (iterator.hasNext()) {
                String item = iterator.next();
                if (item.equals("B")) {
                    iterator.remove();  // 使用同步块，确保线程安全
                }
            }
        }

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

4. 预防措施

4.1 使用线程安全的集合类

使用 java.util.concurrent 包中的线程安全集合类，如 ConcurrentHashMap、CopyOnWriteArrayList，可以避免并发修改问题。

java 复制代码 
import java.util.concurrent.CopyOnWriteArrayList;

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

        for (String item : list) {
            if (item.equals("B")) {
                list.remove(item);  // 使用线程安全的集合类
            }
        }

        System.out.println(list);  // 输出：[A, C]
    }
}
4.2 使用合适的遍历和修改方法

在需要遍历和修改集合时，选择合适的方法和工具，确保操作的安全性和正确性。

4.3 单元测试

编写单元测试来验证集合操作的正确性，确保代码在各种边界条件下都能正确运行。

java 复制代码 
import org.junit.Test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import static org.junit.Assert.*;

public class MainTest {
    @Test
    public void testIteratorRemove() {
        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 (item.equals("B")) {
                iterator.remove();  // 正确使用iterator的remove方法
            }
        }

        assertEquals(2, list.size());
        assertFalse(list.contains("B"));
    }

    @Test(expected = ConcurrentModificationException.class)
    public void testConcurrentModification() {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        for (String item : list) {
            if (item.equals("B")) {
                list.remove(item);  // 直接修改集合，将抛出ConcurrentModificationException
            }
        }
    }
}

结语

理解并有效处理ConcurrentModificationException对于编写健壮的Java程序至关重要。通过本文提供的解决方案和预防措施，开发者可以有效避免和解决这类异常，提高代码质量和可靠性。希望本文能帮助你更好地理解和处理并发修改问题，从而编写出更加可靠的Java应用程序。

相关推荐
qinzechen1 分钟前
分享几个做题网站------学习网------工具网；
java·c语言·c++·python·c#
hakesashou2 分钟前
python交互式命令时如何清除
java·前端·python
攒了一袋星辰2 分钟前
今日指数项目项目集成RabbitMQ与CaffienCatch
java·分布式·rabbitmq
VBA63376 分钟前
VBA数据库解决方案第十五讲：Recordset集合中单个数据的精确处理
开发语言
wrx繁星点点9 分钟前
事务的四大特性（ACID）
java·开发语言·数据库
不写八个16 分钟前
Python办公自动化教程（005）：Word添加段落
开发语言·python·word
IT学长编程16 分钟前
计算机毕业设计 Java酷听音乐系统的设计与实现 Java实战项目 附源码+文档+视频讲解
java·spring boot·毕业设计·课程设计·毕业论文·音乐系统·计算机毕业设计选题
HEX9CF20 分钟前
【CTF Web】Pikachu xss之href输出 Writeup（GET请求+反射型XSS+javascript:伪协议绕过）
开发语言·前端·javascript·安全·网络安全·ecmascript·xss
IT学长编程34 分钟前
计算机毕业设计 基于协同过滤算法的个性化音乐推荐系统的设计与实现 Java实战项目 附源码+文档+视频讲解
java·spring boot·毕业设计·毕业论文·协同过滤算法·计算机毕业设计选题·个性化音乐推荐系统
小小娥子38 分钟前
Redis的基础认识与在ubuntu上的安装教程
java·数据库·redis·缓存
热门推荐
01【经验分享】Ubuntu22.04安装微信(linux官方版)02安卓系列机型永久去除data分区加密 详细步骤解析032024年高教社杯数学建模国赛C题超详细解题思路分析04组基轨迹建模 GBTM的介绍与实现（Stata 或 R）05RAG 实践- Ollama+RagFlow 部署本地知识库06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07分享几个惊艳的 Three.js 个人站点08苍穹外卖面试总结09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文102024CCPC网络预选赛 I. 找行李 【DP】