《Java的并发异常——java.util.ConcurrentModificationException怎么办？》
在Java多线程编程中，`java.util.ConcurrentModificationException`（并发修改异常）是开发者经常遇到的"老朋友"。它像一颗隐藏的定时炸弹，当程序试图在遍历集合的同时修改其内容时，就会突然抛出，导致程序中断。本文将深入剖析这个异常的根源、常见场景、解决方案以及最佳实践，帮助开发者彻底掌握并发环境下的集合操作。
一、异常本质：快速失败（Fail-Fast）机制
ConcurrentModificationException是Java集合框架设计的一种防御性机制，其核心是"快速失败"策略。当检测到集合在迭代过程中被非预期地修改时，立即抛出异常，防止程序进入不可预测的状态。
这个机制的实现依赖于`modCount`变量（modification count）。所有集合类（如ArrayList、HashMap）都维护这个计数器，每次结构性修改（增删元素）都会使其递增。迭代器在初始化时会记录当前的`modCount`值，每次调用`next()`或`remove()`时都会检查这个值是否发生变化。
// ArrayList的Itr内部类实现片段
private class Itr implements Iterator {
int cursor; // 下一个要返回的元素的索引
int lastRet = -1; // 最后一个返回的元素的索引
int expectedModCount = modCount;
public E next() {
checkForComodification();
// ...其他实现
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
} 二、典型触发场景
1. 单线程环境下的不当操作
List list = new ArrayList(Arrays.asList("A", "B", "C"));
Iterator it = list.iterator();
while (it.hasNext()) {
String s = it.next();
if ("B".equals(s)) {
list.remove(s); // 直接通过集合remove()方法修改
}
} 2. 多线程并发修改
List sharedList = new ArrayList();
// 线程1：遍历集合
new Thread(() -> {
for (String s : sharedList) {
System.out.println(s);
}
}).start();
// 线程2：修改集合
new Thread(() -> {
sharedList.add("NewItem");
}).start(); 3. 增强for循环的陷阱
List numbers = new ArrayList(Arrays.asList(1, 2, 3));
for (Integer num : numbers) {
if (num == 2) {
numbers.remove(num); // 抛出异常
}
} 三、解决方案全景图
方案1：使用迭代器的remove()方法
迭代器提供了安全的删除方法，这是单线程环境下的标准解决方案：
List list = new ArrayList(Arrays.asList("A", "B", "C"));
Iterator it = list.iterator();
while (it.hasNext()) {
String s = it.next();
if ("B".equals(s)) {
it.remove(); // 正确方式
}
} 方案2：Java 8+的removeIf()
Java 8引入的集合操作方法提供了更简洁的写法：
List list = new ArrayList(Arrays.asList("A", "B", "C"));
list.removeIf(s -> "B".equals(s)); // 内部使用迭代器实现 方案3：使用并发集合
对于多线程场景，Java并发包提供了线程安全的集合实现：
// CopyOnWriteArrayList：写时复制
List safeList = new CopyOnWriteArrayList();
safeList.add("A");
safeList.add("B");
// 可以安全遍历和修改
for (String s : safeList) {
if ("A".equals(s)) {
safeList.remove(s); // 实际是创建新数组
}
}
// ConcurrentHashMap的示例
Map map = new ConcurrentHashMap();
map.put("A", 1);
map.put("B", 2);
// 使用forEach时需要注意
map.forEach((k, v) -> {
if ("A".equals(k)) {
map.remove(k); // 仍然可能抛出异常，需要特殊处理
}
}); 方案4：显式同步控制
当必须使用非线程安全集合时，可以通过同步机制保护：
List list = new ArrayList();
// ...填充数据
synchronized (list) {
Iterator it = list.iterator();
while (it.hasNext()) {
String s = it.next();
if ("B".equals(s)) {
it.remove();
}
}
} 方案5：使用Java 8 Stream API
Stream API提供了函数式处理方式，但需要注意中间操作和终端操作的区分：
List list = new ArrayList(Arrays.asList("A", "B", "C"));
List filtered = list.stream()
.filter(s -> !"B".equals(s))
.collect(Collectors.toList()); // 创建新集合 四、高级场景处理
1. 复合操作的原子性
当需要"查找并修改"时，简单的迭代器remove()可能不够。此时可以考虑：
// 使用ConcurrentHashMap的compute方法
Map map = new ConcurrentHashMap();
map.put("key", 1);
map.compute("key", (k, v) -> {
if (v == 1) {
return 2; // 原子更新
}
return v;
}); 2. 批量操作优化
对于大量数据的修改，可以考虑批量操作减少同步开销：
List list = new CopyOnWriteArrayList(Arrays.asList("A", "B", "C"));
List toRemove = Arrays.asList("A", "C");
// 批量移除（CopyOnWriteArrayList特有）
list.removeAll(toRemove); // 内部创建新数组 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. 优先使用不可变集合：对于不需要修改的数据，使用`Collections.unmodifiableList()`
2. 明确集合用途：单线程读多写少用ArrayList，多线程环境优先选ConcurrentHashMap
3. 避免在迭代中修改：将需要删除的元素先收集起来，迭代完成后再统一处理
List list = new ArrayList(Arrays.asList("A", "B", "C"));
List toRemove = new ArrayList();
for (String s : list) {
if ("B".equals(s)) {
toRemove.add(s);
}
}
list.removeAll(toRemove); 4. 考虑使用并发工具类：CountDownLatch、CyclicBarrier等协调线程操作
5. 进行压力测试：在并发场景下，使用JMeter等工具验证解决方案的稳定性
六、常见误区解析
误区1："只要用同步块就安全了"
同步块只能保证块内操作的原子性，不能保证整个业务流程的线程安全。例如：
synchronized (list) {
if (!list.contains("X")) { // 检查
list.add("X"); // 执行
}
}这段代码在多线程下仍可能产生重复元素，因为检查和执行之间存在时间差。
误区2："Vector和Hashtable是绝对安全的"
这些古老集合类确实提供了同步方法，但性能较差，且复合操作仍需额外同步。例如：
Vector vector = new Vector();
// 以下操作不是原子的
if (vector.size() > 0) {
vector.remove(0);
} 误区3："并发集合性能一定更好"
并发集合通过精细的同步机制保证安全，但带来了性能开销。在单线程或低并发场景下，普通集合可能更高效。
七、未来演进方向
1. Java 9的改进：`List.of()`和`Set.of()`创建的不可变集合完全避免了修改问题
2. VarHandles和原子类：Java 9引入的VarHandle提供了更细粒度的内存操作控制
3. 虚拟线程（Project Loom）：预计将简化并发编程模型，但集合操作的基本原则仍然适用
关键词：ConcurrentModificationException、快速失败、迭代器、并发集合、CopyOnWriteArrayList、同步控制、Java并发、多线程编程
简介：本文深入解析Java中ConcurrentModificationException异常的成因与解决方案，涵盖单线程和多线程场景下的最佳实践。从快速失败机制原理出发，详细讨论了迭代器安全操作、Java 8新特性、并发集合使用、同步控制策略等解决方案，并提供了实际代码示例和性能考量，帮助开发者构建健壮的并发程序。
