绕过迭代器遍历时的数据修改异常的方法有哪些

# 绕过迭代器遍历时的数据修改异常的方法有哪些

## 摘要
本文深入探讨了迭代器遍历过程中数据修改异常的成因、表现及解决方案。通过分析并发修改异常（ConcurrentModificationException）的产生机制，系统性地介绍了6种绕过异常的有效方法，包括使用线程安全集合、快照迭代、显式迭代器操作等，并结合实际场景提供了最佳实践建议。

---

## 一、迭代器数据修改异常概述

### 1.1 异常产生机制
当使用迭代器遍历集合时，Java会通过`modCount`机制检测结构性修改：
```java
final void checkForCommodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

• modCount：记录集合结构修改次数的计数器
• expectedModCount：迭代器初始化时记录的modCount值

1.2 典型触发场景

二、6种核心解决方案

2.1 使用线程安全集合（推荐方案）

List<String> safeList = Collections.synchronizedList(new ArrayList<>());
// 遍历时需要手动同步
synchronized(safeList) {
    Iterator<String> it = safeList.iterator();
    while(it.hasNext()) {
        String item = it.next();
        // 安全操作
    }
}

并发集合对比：

2.2 创建集合快照

List<String> snapshot = new ArrayList<>(originalList);
for(String item : snapshot) {
    // 修改originalList不会影响遍历
}

适用场景： - 集合规模较小（避免内存浪费） - 需要遍历时保持数据一致性视图

2.3 显式使用迭代器修改

ListIterator<String> it = list.listIterator();
while(it.hasNext()) {
    String item = it.next();
    if(needRemove(item)) {
        it.remove(); // 合法修改
    }
}

注意事项： - 仅remove()和set()方法安全 - 添加元素需使用listIterator.add()

2.4 标记-清除模式

List<String> toRemove = new ArrayList<>();
for(String item : list) {
    if(shouldRemove(item)) {
        toRemove.add(item);
    }
}
list.removeAll(toRemove);

优势： - 适用于复杂条件删除 - 避免在迭代中修改

2.5 使用函数式编程（Java8+）

list.removeIf(item -> item.contains("test"));
list.replaceAll(String::toUpperCase);

性能对比：

2.6 反向遍历删除

for(int i = list.size()-1; i >=0; i--) {
    if(condition(list.get(i))) {
        list.remove(i); // 不会影响未遍历索引
    }
}

适用场景： - 顺序列表的批量删除 - 索引敏感的修改操作

三、多线程环境特殊处理

3.1 读写锁方案

ReadWriteLock rwLock = new ReentrantReadWriteLock();
rwLock.readLock().lock();
try {
    // 迭代操作
} finally {
    rwLock.readLock().unlock();
}

rwLock.writeLock().lock();
try {
    // 修改操作
} finally {
    rwLock.writeLock().unlock();
}

3.2 并发修改检测策略

List<String> list = new ArrayList<>();
// 使用volatile计数器
volatile int version = 0;

void safeIterate() {
    int currentVersion = version;
    for(String s : list) {
        if(currentVersion != version) {
            throw new ConcurrentModificationException();
        }
        // 处理元素
    }
}

四、最佳实践建议

1. 选择准则：

   • 单线程环境优先使用Iterator.remove()
   • 多线程场景推荐CopyOnWriteArrayList
   • 批量操作考虑removeIf/replaceAll

2. 性能优化技巧：

   • 对大型集合使用分块处理

   int chunkSize = 1000;
   for(int i=0; i<list.size(); i+=chunkSize) {
      List<String> sub = list.subList(i, Math.min(i+chunkSize, list.size()));
      sub.removeIf(...);
   }
   

3. 异常处理模板：

try {
    for(String item : list) {
        process(item);
    }
} catch(ConcurrentModificationException ex) {
    log.warn("检测到并发修改，自动重试");
    // 自动恢复逻辑
}

五、总结

本文涵盖的解决方案可归纳为三个层次： 1. 预防层面：使用线程安全集合、快照隔离 2. 控制层面：通过迭代器API规范修改 3. 恢复层面：异常捕获与重试机制

实际开发中应根据具体场景选择组合方案，对于关键业务系统建议采用CopyOnWrite集合+原子操作的黄金组合。

扩展思考： - Java 9新增的ImmutableCollections对迭代安全的影响 - 响应式编程中的流式处理如何避免修改异常 “`