一段清理过期数据的代码,逻辑是遍历列表,符合条件的删掉。测试环境跑了几十次都没问题,线上偶尔抛 ConcurrentModificationException,更奇怪的是有时候不抛,只是结果少删了几条。开发的第一反应是「是不是多线程」,查了半天发现整个方法就在一个线程里跑。

问题跟线程无关。Java 的集合在遍历时被修改,行为本来就没有保证:某些位置会立刻抛异常,某些位置会静默地漏掉元素。这段代码踩中的是 ArrayList 的迭代器检查机制,而不是并发。把「集合」和「并发集合」混为一谈,是这类误判的根源。

这篇讲集合的选型、迭代器的检查、几个长得像集合其实是「视图」的返回值、Stream 的惰性,以及 parallelStream 的公共线程池。目标很具体:下次看到 ConcurrentModificationException 或结果不对,能立刻知道是哪一类问题。

先复现:删第二个元素,居然不报错

很多人对 ConcurrentModificationException 的印象是「遍历时修改就一定报错」。实际跑一下会发现不是这样。下面两段代码结构完全一样,只是删除的位置不同:

List<String> a = new ArrayList<>(List.of("a", "b", "c"));
for (String n : a) {
    if (n.equals("a")) a.remove(n);
}

List<String> b = new ArrayList<>(List.of("a", "b", "c"));
for (String n : b) {
    if (n.equals("b")) b.remove(n);
}
javac -encoding UTF-8 CmeDemo.java
java -Dstdout.encoding=UTF-8 -cp . CmeDemo

删除第一个元素抛出 : ConcurrentModificationException
删除第二个元素后 : [a, c]

第一段抛了异常,第二段没有,列表变成了 [a, c],看起来「正常」。原因是 ArrayList 的迭代器在每次取下一个元素时检查修改次数,但它的 hasNext 只看游标是否小于当前大小。删掉第二个元素后大小变成 2,游标刚好也是 2,循环直接结束,检查根本没轮到。删掉第一个元素时游标是 1,大小是 2,还会再取一次,检查就触发了。

这就是它危险的地方:报错至少还能发现,不报错的那次会悄悄改变结果。如果被删的是需要保留的数据,或者循环里还做了计数、累加,错误会一路带到下游,日志上什么都看不出来。

先选对容器:List、Set、Map 的取舍

集合框架的接口主要有三个:List 有序、可重复、按位置访问;Set 不重复,是否有序看具体实现;Map 存键值对,键不重复。接口只规定行为,真正决定性能的是底层实现。

实现底层结构顺序典型操作代价适合的场景
ArrayList连续数组插入顺序按下标读 O(1),中间插入删除 O(n)读多写少、需要按下标访问
LinkedList双向链表插入顺序按下标读 O(n),两端增删 O(1)频繁在头部增删、当队列用
HashSet哈希表不保证增删查平均 O(1)去重、判断存在
LinkedHashSet哈希表加链表插入顺序增删查平均 O(1),略慢于 HashSet去重同时要保留顺序
TreeSet红黑树排序顺序增删查 O(log n)需要按大小排序或取范围
HashMap哈希表不保证增删查平均 O(1)按 key 快速查找
LinkedHashMap哈希表加链表插入或访问顺序增删查平均 O(1)需要稳定遍历顺序、做简单 LRU
TreeMap红黑树按键排序增删查 O(log n)按 key 排序、范围查询

几个常见误区。第一,LinkedList 并不总是比 ArrayList 快:按下标访问要一个个走,实际项目里 ArrayList 的命中率更高。第二,HashSet 和 HashMap 依赖元素的 hashCode 与 equals,自定义类没重写这两个方法,去重就会失效。第三,把可变对象当 HashMap 的键,修改对象内容后哈希值变了,再也查不到,和上一篇 record 的坑是同一个原因。

当队列用的时候,优先考虑 ArrayDeque,它在两端增删都是 O(1),比 LinkedList 少一层节点对象开销,也比 Stack 更现代。Stack 是早期遗留类,方法带同步锁,单线程下白付代价。需要「后进先出」就用 ArrayDeque,需要「先进先出」也用它,别在 LinkedList 和 Stack 之间反复犹豫。

还有一个容量细节:ArrayList 和 HashMap 都会扩容。能提前估算大小时,构造时传容量可以减少多次复制和重新哈希。但别为了「优化」到处传一个巨大的初始容量,那会直接占住内存。

迭代器与 fail-fast:检查是尽力而为

增强 for 循环(for-each)在编译后会被改写成迭代器调用:先 iterator(),再反复 hasNext() 和 next()。ArrayList 的迭代器内部记着一个期望的修改次数,集合每次结构性修改(增、删、扩容导致的元素搬移)都会把这个计数加一。迭代器发现实际值和期望值对不上,就抛 ConcurrentModificationException。

这套机制叫 fail-fast,意思是「发现不对劲就赶紧失败」。但它是尽力而为,不是并发安全保证:检查不是原子的,多线程下可能漏检,也可能在检查之后才被改。所以不能拿它当「有没有并发修改」的证据,更不能靠它保证线程安全。

集合对象维护元素数组、大小和一个修改计数。所有结构性修改都会让计数变化。
迭代器创建时记下当时的修改计数,每次取元素前对比。对不上就抛出异常,并停止遍历。
你的循环for-each 或显式迭代器。只要在循环里直接调用集合的增删方法,就可能让迭代器的计数过期。

正确做法有三种:用迭代器自己的 remove(),它会在删除后同步更新期望计数;用 removeIf,一行搞定且内部处理了计数;或者先收集要删的元素,循环结束后统一删除。前两种适合单线程,第三种最直观,也最不容易写错。

索引循环也有自己的坑。边遍历边删时下标会前移,后面的元素被跳过;倒着删可以避开这个问题,但可读性差。集合的 size() 在循环条件里反复求值,如果循环体修改了集合,边界也会变。这些都不是语法错误,编译器不会提醒。

如果确实需要多线程读写同一个列表,普通 ArrayList 加 synchronized 块既慢又容易漏;Collections.synchronizedList 能包一层同步,但遍历时仍然要自己持锁。CopyOnWriteArrayList 采用「写时复制」,读操作完全不加锁,适合读多写极少的场景;每次写都会复制整个数组,写频繁时开销很大。选哪个取决于读写比例,没有通用答案。

视图:看起来是新集合,其实共用数据

有几个方法返回的对象并不是「新集合」,而是原数据的另一个视角。改视图会影响原集合,改原集合也可能让视图失效。这类问题最容易被「我明明复制了一份」的错觉误导。

List<Integer> fixed = Arrays.asList(1, 2, 3);
fixed.set(0, 9);
System.out.println(fixed);

List<String> all = new ArrayList<>(List.of("x", "y", "z"));
List<String> view = all.subList(0, 2);
view.set(0, "X");
System.out.println(all);
all.add("w");
System.out.println(view.get(0));
[9, 2, 3]
[X, y, z]
ConcurrentModificationException

Arrays.asList 返回的是一个固定长度的列表,底层就是原数组。可以 set 改元素,但 add 和 remove 会抛 UnsupportedOperationException,因为它没有地方扩容。想要真正可变的列表,包一层 new ArrayList<>(Arrays.asList(...))。

subList 返回的是原列表的视图,不是拷贝。改视图里的元素,原列表跟着变;原列表做了结构性修改之后,再访问视图就可能抛 ConcurrentModificationException,因为视图背后记的修改计数过期了。需要独立副本就写 new ArrayList<>(list.subList(...))。

List.of 返回的是真正不可变的列表,任何修改都抛 UnsupportedOperationException,而且不接受 null 元素。它适合做常量、方法返回值、测试数据。注意 Collections.unmodifiableList 只是「只读视图」:你不能通过它修改,但原列表被别人改了,它里面的内容照样会变。

Map 也有视图。keySet()、values()、entrySet() 返回的都和原 Map 共享数据,从 keySet 里删一个键,原 Map 里对应的条目就没了。遍历 Map 时想删条目,同样要走 entrySet 的迭代器或者 removeIf,不能一边 for-each 一边调 map.remove。

判断一个返回值是拷贝还是视图,最直接的办法是看文档,或者做一次小实验:改一处,看另一处是否跟着变。不要凭方法名猜,「asList」「subList」都不是「copy」。

Stream:不调用终止操作,就什么都不会发生

Stream 不是集合,它是一条「数据处理流水线」。中间操作(filter、map、sorted、peek)只是描述步骤,返回新的 Stream,不会立刻执行;终止操作(collect、count、forEach、findFirst、anyMatch)才会真正开始遍历。

List<String> lazy = new ArrayList<>(List.of("1", "2", "3"));
Stream<String> stream = lazy.stream().peek(x -> System.out.println("peek " + x));
System.out.println("stream 已创建");
stream.collect(Collectors.toList());
System.out.println("collect 之后结束");
stream 已创建
peek 1
peek 2
peek 3
collect 之后结束

「stream 已创建」先打印,说明中间操作确实没执行。这也是为什么在 peek 里做业务逻辑很危险:没有终止操作,它一行都不会跑;有了终止操作,它又可能在你不期望的时机跑。调试可以,正式逻辑别放里面。

Stream 还有两个容易忽略的限制。第一,一个 Stream 只能消费一次,第二次调用终止操作会抛 IllegalStateException,信息是 stream has already been operated upon or closed。第二,findFirst、anyMatch、limit 这类短路操作不会遍历完所有元素,依赖「每个元素都被处理」的副作用会漏掉。

短路特性本身是优点:在一个很大的列表里找第一个符合条件的元素,findFirst 找到就停,不会白跑后面的数据。但把它和 peek 里的计数、日志混在一起,就容易得出「只处理了三条」的错觉。需要完整统计就用 count,需要逐条记录就把副作用移到循环里,别藏在流水线中间。

收集阶段最常用的是 Collectors。下面几个坑都来自真实项目:

  • toMap 遇到重复键直接抛 IllegalStateException,信息是 Duplicate key a (attempted merging values 1 and 1)。要么保证键唯一,要么传第三个参数指定合并规则。
  • toMap 的值为 null 时也会抛空指针,因为底层 HashMap 的合并逻辑不允许 null 值。先过滤掉,或者改用 forEach 手工放。
  • groupingBy 的分类函数返回 null 会抛空指针。分类前先处理空值,或者显式指定一个「未知」分组。
  • 在 forEach 里往外部集合添加元素,遇到并行流会线程不安全。收集结果用 collect,别用共享容器。

另外,Stream 的调试堆栈很长,异常里常常出现 lambda$main$3 这样的名字。线上出问题时,先把 Stream 拆成几步、给关键步骤加日志,比盯着一条长链更容易定位。

parallelStream:共享的公共池,不是免费的加速

list.parallelStream() 会把任务切分到 ForkJoinPool.commonPool() 上并行执行。这个池是 JVM 进程内所有并行流共用的,默认并行度是「可用处理器数减一」。本机跑出来是 11 和 12:

System.out.println(ForkJoinPool.commonPool().getParallelism());
System.out.println(Runtime.getRuntime().availableProcessors());
11
12

公共池只有这么大,意味着任何一处并行流里做慢操作,都会占住线程,让别处的并行流排队。更糟的是在公共池的任务里做阻塞式 IO 或等待锁:线程被卡住,池子没有多余线程可以补,整个进程里所有依赖公共池的代码都会变慢。这不是「偶尔慢一点」,而是会传染的。

适合并行的场景有三个前提:数据量大、每个元素的计算是纯 CPU 操作、元素之间没有共享可变状态。排序、复杂计算、大批量转换可以考虑。读文件、调接口、查数据库这类 IO 操作不适合,瓶颈在等待,增加线程只会增加压力。

还有顺序问题:forEach 在并行流下不保证顺序,需要顺序就用 forEachOrdered,但那会牺牲一部分并行收益。带状态的 lambda(比如往同一个 ArrayList 里加元素)在并行流下结果不确定,必须换成 collect。

如果确实需要并行又不想影响公共池,可以自己建一个 ForkJoinPool,把任务提交进去执行,用完关闭。这样至少能把影响范围限制在自己的模块里。但自建池也要控制大小,池子开得比 CPU 核数大很多,线程切换和内存占用都会上升,收益未必为正。

不要因为「parallel 看起来更快」就给所有流加上 parallelStream。小数据量下切分和合并的开销可能比串行还大,而且公共池被打满之后,问题会出现在完全不相干的模块里,排查时很难联想到是某处并行流引起的。

出问题时先看哪里

现象真实原因第一步查什么
遍历时删元素抛 ConcurrentModificationException直接调用了集合的 remove,迭代器的修改计数过期看循环里有没有 list.remove;改用 iterator.remove 或 removeIf
遍历删元素不报错,但结果少了删除位置刚好让 hasNext 提前为 false,跳过检查也跳过元素不要依赖「没抛异常」判断正确;改成先收集再统一删除
Arrays.asList 调 add 抛异常返回的是固定长度视图,底层是原数组确认是否需要可变列表;需要就包一层 new ArrayList<>(...)
改了 subList 结果,原列表也变了subList 是视图,不是拷贝看是否要独立副本;要就复制一份
Stream 里的日志一行都没打印只有中间操作,没有终止操作,流水线没有启动检查链尾有没有 collect、count、forEach 等终止操作
同一个 Stream 第二次使用抛异常Stream 只能消费一次把 Stream 存成集合,或者每次从源重新创建
toMap 抛 Duplicate key键重复,默认合并策略是直接抛异常确认键是否唯一;需要保留就传合并函数
并行流跑完,结果顺序乱了或数量不对forEach 不保证顺序,共享容器不是线程安全的改用 collect 或 forEachOrdered;检查 lambda 是否修改共享状态
某模块突然变慢,线程池指标正常别处的 parallelStream 占满了公共池,还在做阻塞操作搜代码里的 parallelStream 和 ForkJoinPool.commonPool 使用

排查顺序可以固定成三步:先确认是「单线程集合误用」还是「真并发」;再看返回值是拷贝还是视图;最后才怀疑 Stream 的惰性和并行。绝大多数集合问题在第一步就能定性。

边界与代价

集合和 Stream 用起来顺手,但每一层抽象都有成本,提前知道能少踩坑:

  • 哈希集合依赖 hashCode:自定义对象不重写 equals 和 hashCode,去重和查找都会失效;重写了但字段可变,修改后同样失效。
  • 扩容有一次性开销:ArrayList 扩容要复制数组,HashMap 扩容要重新分配桶。数据量可预估时传初始容量,但别传得离谱。
  • 视图不是拷贝:Arrays.asList、subList、unmodifiableList 都和原数据共享存储,生命周期和修改规则要一起考虑。
  • Stream 不适合复杂控制流:需要 break、多层 continue、边遍历边修改状态时,普通循环更清楚。Stream 的优势是表达「转换和收集」,不是替代所有循环。
  • 并行流不解决 IO 瓶颈:它的线程数有限,任务还会互相挤占。IO 密集的并发要靠专门的线程池或异步 API,不能指望 parallelStream。
  • 拆箱与装箱:Stream<Integer> 的求和、比较都可能装箱。数值密集的计算可以用 IntStream、LongStream 避开一部分开销。

最后一点关于可读性:链式 Stream 写得太长,排查时很难说清哪一步出了错。一个经验是超过五六步就拆开,中间结果赋给有名字的变量。代码是给人看的,编译器不在乎你写几行。

当天能自己验证的练习

  1. 构造 [a, b, c],分别删除第一个和第二个元素,记录两次结果。确认「不报错」不等于「删对了」,并解释游标和 hasNext 的关系。
  2. 用 Arrays.asList 得到一个列表,依次调用 set、add、remove,记录哪些成功、哪些抛异常,异常类型是什么。
  3. 对一个列表取 subList,先改视图再打印原列表,然后给原列表 add 一个元素,再访问视图,观察异常出现的时机。
  4. 写一条只含 filter 和 peek 的 Stream,不加终止操作,确认什么都不打印;再加上 collect,观察打印顺序。
  5. 用 Collectors.toMap 处理一个含重复键的列表,记录异常原文;再传入合并函数,确认能得到预期结果。

小结

三句话收一下:遍历时修改集合的行为没有保证,报错和不报错都可能发生,正确做法是 iterator.remove、removeIf 或先收集后删除;Arrays.asList、subList、unmodifiableList 返回的是视图,不是拷贝;Stream 不调用终止操作就什么都不做,并行流共用一个小池子,不适合塞阻塞任务。

下一篇讲文件与 NIO。集合解决的是内存里的数据,NIO 解决的是磁盘上的数据;今天遇到的「视图」和「惰性」思路会再次出现,比如 Files.lines 返回的流必须关闭,Files.walk 也是懒加载的。