Java中的ConcurrentModificationException异常该如何处理？

《Java中的ConcurrentModificationException异常该如何处理？》

在Java多线程编程中，ConcurrentModificationException（并发修改异常）是开发者经常遇到的"隐形炸弹"。这个异常通常发生在单线程环境下对集合的迭代过程中，当集合被意外修改时抛出；而在多线程场景下，由于竞态条件（Race Condition）的存在，该异常更易发生且更难排查。本文将从异常本质、产生原因、解决方案到最佳实践，系统剖析这一常见问题的处理之道。

一、异常本质与触发场景

ConcurrentModificationException继承自RuntimeException，是Java集合框架对"快速失败"（Fail-Fast）机制的实现。当检测到集合结构被意外修改时（如添加、删除元素），迭代器会主动抛出此异常以防止不可预测的行为。

典型触发场景：

List list = new ArrayList(Arrays.asList("A", "B", "C"));
for (String s : list) {
    if ("B".equals(s)) {
        list.remove(s); // 抛出ConcurrentModificationException
    }
}

上述代码中，增强for循环内部修改集合结构导致modCount（修改计数器）与expectedModCount（预期修改计数）不一致，触发异常。在多线程环境下，即使使用传统for循环也可能因并发修改而抛出异常。

二、单线程环境解决方案

1. 使用迭代器的remove()方法

迭代器提供了安全的元素删除方式，通过调用迭代器的remove()方法可以同步更新modCount：

List list = new ArrayList(Arrays.asList("A", "B", "C"));
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
    String s = iterator.next();
    if ("B".equals(s)) {
        iterator.remove(); // 安全删除
    }
}

2. CopyOnWrite模式

对于读多写少的场景，CopyOnWriteArrayList通过创建新数组副本实现写操作隔离：

List list = new CopyOnWriteArrayList(Arrays.asList("A", "B", "C"));
for (String s : list) {
    if ("B".equals(s)) {
        list.remove(s); // 不会抛出异常（但实际会创建新数组）
    }
}

注意：此方式适用于元素数量少且修改不频繁的场景，频繁修改会导致内存开销剧增。

3. 普通for循环倒序遍历

对于ArrayList等基于索引的集合，倒序遍历可避免索引错位问题：

List list = new ArrayList(Arrays.asList("A", "B", "C"));
for (int i = list.size() - 1; i >= 0; i--) {
    if ("B".equals(list.get(i))) {
        list.remove(i);
    }
}

三、多线程环境解决方案

1. 同步控制（Synchronized）

使用显式锁或同步块保证原子性：

List synchronizedList = Collections.synchronizedList(new ArrayList());
// 或
List list = new ArrayList();
Object lock = new Object();

// 线程1（修改线程）
synchronized (lock) {
    list.add("D");
}

// 线程2（遍历线程）
synchronized (lock) {
    for (String s : list) {
        System.out.println(s);
    }
}

缺点：粗粒度锁可能导致性能瓶颈，需合理设计锁粒度。

2. 并发集合类

Java并发包（java.util.concurrent）提供了多种线程安全集合：

• CopyOnWriteArrayList：写时复制，适合读多写少
• ConcurrentHashMap：分段锁技术，高并发读写
• ConcurrentLinkedQueue：非阻塞队列

// ConcurrentHashMap示例
Map map = new ConcurrentHashMap();
map.put("key1", "value1");

// 遍历方式1：使用entrySet()
for (Map.Entry entry : map.entrySet()) {
    System.out.println(entry.getKey() + ":" + entry.getValue());
}

// 遍历方式2：Java 8+ forEach
map.forEach((k, v) -> System.out.println(k + ":" + v));

3. 显式锁（ReentrantLock）

对于复杂操作场景，ReentrantLock提供更灵活的锁控制：

Lock lock = new ReentrantLock();
List list = new ArrayList();

// 修改操作
lock.lock();
try {
    list.add("E");
} finally {
    lock.unlock();
}

// 遍历操作
lock.lock();
try {
    Iterator it = list.iterator();
    while (it.hasNext()) {
        System.out.println(it.next());
    }
} finally {
    lock.unlock();
}

4. 读写锁（ReentrantReadWriteLock）

分离读写操作，提高并发性能：

ReadWriteLock rwLock = new ReentrantReadWriteLock();
List list = new ArrayList();

// 写操作
rwLock.writeLock().lock();
try {
    list.add("F");
} finally {
    rwLock.writeLock().unlock();
}

// 读操作
rwLock.readLock().lock();
try {
    for (String s : list) {
        System.out.println(s);
    }
} finally {
    rwLock.readLock().unlock();
}

四、高级解决方案

1. Java 8 Stream API

通过并行流（parallelStream）实现自动并行处理：

List list = new ArrayList(Arrays.asList("A", "B", "C"));
List result = list.parallelStream()
    .filter(s -> !"B".equals(s))
    .collect(Collectors.toList());

注意：需确保操作是线程安全的，filter等中间操作本身是线程安全的。

2. 不可变集合

使用Collections.unmodifiableList创建不可变集合：

List original = new ArrayList(Arrays.asList("A", "B", "C"));
List unmodifiable = Collections.unmodifiableList(original);

// 尝试修改会抛出UnsupportedOperationException
// unmodifiable.add("D");

3. 自定义迭代器

实现自定义迭代器处理修改逻辑：

public class SafeIterator implements Iterator {
    private final List list;
    private Iterator iterator;
    private int expectedModCount;

    public SafeIterator(List list) {
        this.list = list;
        this.iterator = list.iterator();
        this.expectedModCount = list.size(); // 简化示例
    }

    @Override
    public boolean hasNext() {
        checkForComodification();
        return iterator.hasNext();
    }

    @Override
    public E next() {
        checkForComodification();
        return iterator.next();
    }

    private void checkForComodification() {
        if (list.size() != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }
}

五、最佳实践建议

1. 优先使用并发集合：在多线程环境中，ConcurrentHashMap、CopyOnWriteArrayList等专用集合类通常是最佳选择。

2. 合理选择同步策略：根据场景选择细粒度锁（如ReentrantLock）或粗粒度同步（synchronized），避免过度同步。

3. 避免在迭代中修改集合：即使使用并发集合，也建议将修改操作移到迭代过程之外。

4. 考虑不可变模式：对于配置类数据，使用不可变集合可彻底避免并发修改问题。

5. 进行压力测试：并发程序需通过多线程测试验证，JMeter或CountDownLatch可辅助测试。

六、案例分析：电商库存系统

考虑一个电商库存系统，多个用户同时下单可能导致库存超卖：

// 错误示例（并发问题）
public class Inventory {
    private List products = new ArrayList();
    
    public void purchase(String productId) {
        for (Product p : products) {
            if (p.getId().equals(productId) && p.getStock() > 0) {
                p.setStock(p.getStock() - 1); // 并发修改异常风险
                break;
            }
        }
    }
}

// 正确实现（使用并发集合）
public class ConcurrentInventory {
    private ConcurrentHashMap products = new ConcurrentHashMap();
    
    public boolean purchase(String productId) {
        return products.compute(productId, (k, v) -> {
            if (v != null && v.getStock() > 0) {
                v.setStock(v.getStock() - 1);
                return v;
            }
            return null;
        }) != null;
    }
}

七、常见误区解析

1. 误认为Vector能解决所有问题：Vector的同步是方法级的，复合操作仍需额外同步。

2. 过度使用CopyOnWrite：写频繁场景下性能急剧下降，内存消耗大。

3. 忽略迭代器状态：即使使用并发集合，迭代过程中集合被修改仍可能导致不可预期行为。

4. 锁粒度不当：锁范围过大导致并发度降低，过小则可能引发死锁。

八、性能对比分析

| 方案 | 读性能 | 写性能 | 内存开销 | 适用场景 | |------|--------|--------|----------|----------| | SynchronizedList | 中 | 低 | 低 | 低并发简单场景 | | CopyOnWriteArrayList | 高 | 极低 | 高 | 读多写少，元素少 | | ConcurrentHashMap | 极高 | 高 | 中 | 高并发读写 | | ReentrantLock | 可调 | 可调 | 低 | 复杂同步需求 |

关键词：ConcurrentModificationException、Java并发、集合框架、Fail-Fast、多线程编程、并发集合、同步控制、CopyOnWrite、ReentrantLock

简介：本文系统解析Java中ConcurrentModificationException异常的产生机理，从单线程迭代修改到多线程并发场景提供完整解决方案，涵盖同步控制、并发集合、锁机制等核心技术，结合电商案例与性能对比，给出从基础修复到架构优化的实践指南。