【Java】解决Java报错：ConcurrentModificationException

在这里插入图片描述

文章目录

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

引言

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

1. 错误详解

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

2. 常见的出错场景

2.1 遍历过程中修改集合

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

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 方法，也会引发该异常。

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。

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，它在每次修改时都会创建集合的副本，避免并发修改问题。

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 块来同步对集合的访问，确保在遍历时不会被其他线程修改。

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，可以避免并发修改问题。

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 单元测试

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

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
            }
        }
    }
}