一段清理过期数据的代码,逻辑是遍历列表,符合条件的删掉。测试环境跑了几十次都没问题,线上偶尔抛 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,意思是「发现不对劲就赶紧失败」。但它是尽力而为,不是并发安全保证:检查不是原子的,多线程下可能漏检,也可能在检查之后才被改。所以不能拿它当「有没有并发修改」的证据,更不能靠它保证线程安全。
正确做法有三种:用迭代器自己的 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。
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 核数大很多,线程切换和内存占用都会上升,收益未必为正。
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 写得太长,排查时很难说清哪一步出了错。一个经验是超过五六步就拆开,中间结果赋给有名字的变量。代码是给人看的,编译器不在乎你写几行。
当天能自己验证的练习
- 构造
[a, b, c],分别删除第一个和第二个元素,记录两次结果。确认「不报错」不等于「删对了」,并解释游标和hasNext的关系。 - 用
Arrays.asList得到一个列表,依次调用set、add、remove,记录哪些成功、哪些抛异常,异常类型是什么。 - 对一个列表取
subList,先改视图再打印原列表,然后给原列表add一个元素,再访问视图,观察异常出现的时机。 - 写一条只含
filter和peek的 Stream,不加终止操作,确认什么都不打印;再加上collect,观察打印顺序。 - 用
Collectors.toMap处理一个含重复键的列表,记录异常原文;再传入合并函数,确认能得到预期结果。
小结
三句话收一下:遍历时修改集合的行为没有保证,报错和不报错都可能发生,正确做法是 iterator.remove、removeIf 或先收集后删除;Arrays.asList、subList、unmodifiableList 返回的是视图,不是拷贝;Stream 不调用终止操作就什么都不做,并行流共用一个小池子,不适合塞阻塞任务。
下一篇讲文件与 NIO。集合解决的是内存里的数据,NIO 解决的是磁盘上的数据;今天遇到的「视图」和「惰性」思路会再次出现,比如 Files.lines 返回的流必须关闭,Files.walk 也是懒加载的。