【Java】解决Java报错:ConcurrentModificationException

文章目录

      • 引言
      • [1. 错误详解](#1. 错误详解)
      • [2. 常见的出错场景](#2. 常见的出错场景)
        • [2.1 遍历过程中修改集合](#2.1 遍历过程中修改集合)
        • [2.2 使用 `Iterator` 进行删除操作](#2.2 使用 Iterator 进行删除操作)
      • [3. 解决方案](#3. 解决方案)
        • [3.1 使用 `Iterator` 的 `remove` 方法](#3.1 使用 Iteratorremove 方法)
        • [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 进行删除操作

直接使用 Iteratorremove 方法可以避免 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 使用 Iteratorremove 方法

正确地使用 Iteratorremove 方法可以避免 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 包中的线程安全集合类,如 ConcurrentHashMapCopyOnWriteArrayList,可以避免并发修改问题。

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应用程序。

相关推荐
XiaoLeisj2 小时前
【JavaEE初阶 — 多线程】单例模式 & 指令重排序问题
java·开发语言·java-ee
paopaokaka_luck2 小时前
【360】基于springboot的志愿服务管理系统
java·spring boot·后端·spring·毕业设计
dayouziei2 小时前
java的类加载机制的学习
java·学习
励志成为嵌入式工程师3 小时前
c语言简单编程练习9
c语言·开发语言·算法·vim
捕鲸叉3 小时前
创建线程时传递参数给线程
开发语言·c++·算法
A charmer3 小时前
【C++】vector 类深度解析:探索动态数组的奥秘
开发语言·c++·算法
Peter_chq3 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
Yaml44 小时前
Spring Boot 与 Vue 共筑二手书籍交易卓越平台
java·spring boot·后端·mysql·spring·vue·二手书籍
小小小妮子~4 小时前
Spring Boot详解:从入门到精通
java·spring boot·后端
hong1616884 小时前
Spring Boot中实现多数据源连接和切换的方案
java·spring boot·后端