并行流
并行流把输入拆成多个分区,让多个线程分别处理,再按终止操作的规则得到结果。它能缩短计算时间,也会增加拆分、调度和合并的成本。数据容易拆分、计算彼此独立、机器还有可用 CPU 时,才更有机会从中获益。
把 stream() 改成 parallelStream() 很简单,但原来只在一个线程里执行的函数,现在可能由多个线程同时调用。服务端还要考虑执行资源:普通线程发起的并行流在 OpenJDK 21 中使用公共线程池,可能与同一进程的其他任务竞争。判断能不能用,既要确认结果正确,也要测量整体性能。
1. 面试核心
先记住这几条,再读正文- 并行流用
Spliterator.trySplit()把数据范围逐级拆小,各分区算完后,再按终止操作的规则合并结果。 - Fork/Join 的每个工作线程先处理自己双端队列里的任务,空闲线程从别的队列另一端窃取尚未执行的任务,以此缓解负载不均。卡 · Spliterator 拆分
- 有序流的元素可以并发计算,
toList()等操作仍会按遇到顺序组织结果;计算顺序和结果顺序是两回事。 - OpenJDK 21 中,普通线程发起的并行流使用进程共享的
ForkJoinPool.commonPool()。阻塞任务占住工作线程时,其他使用者也可能被拖慢。 - 并行收益取决于拆分质量、单项计算量和可用 CPU,调度、合并和共享状态竞争都是额外成本,需要用接近生产的基准来确认。卡 · 外部可变状态
2. Spliterator 拆分
Spliterator 是既能遍历、又能拆分数据源的接口。多个线程要分工,先要靠它把输入分开。并行流水线通过 trySplit() 逐步拆出子范围,下面是均匀拆分 16 项数据的例子:
[0 ................ 15]
/ \
[0 ...... 7] [8 ...... 15]
/ \ / \
[0..3] [4..7] [8..11] [12..15]
16 项数据经过两轮拆分,变成四个各含 4 项的分区。拆分成本取决于数据源:数组和 ArrayList 可以按下标划定范围;链式结构需要遍历节点,拆分时可能还要把一批元素复制出来;大小未知的迭代器或 I/O 数据源也可能需要先读出一批,再交给子任务。拆分越费时、分区越不均匀,能够并行节省的时间就越少。
即使拆得很均匀,每个元素的耗时也可能不同,有的分区会先算完。下一节的工作窃取处理的就是这种不均衡。
Spliterator 还通过特征值(characteristics)声明数据是否有序(ORDERED)、大小是否已知(SIZED)、元素是否互异(DISTINCT),Stream 据此选择拆分和合并的策略。
3. ForkJoinPool
Fork/Join 是把大任务拆成子任务(fork),再等待并组合子任务结果(join)的执行模型。ForkJoinPool 为这些任务提供工作线程,并通过工作窃取分配尚未执行的任务。
在 OpenJDK 21 中,从普通线程发起的并行流使用公共池 ForkJoinPool.commonPool(),发起调用的线程自己也会参与计算;如果是在某个 ForkJoinPool 的工作线程里发起,子任务会提交到这个线程所在的池。这些都是实现行为,Stream API 本身没有提供指定线程池的参数。
工作窃取(work stealing)是让空闲线程从其他线程的队列中取走尚未执行的任务,分担剩余工作。一次并行计算大致这样展开:
- 大任务递归拆成较小任务。
- 每个工作线程(下文称 Worker)优先处理自己双端队列里的任务。
- 空闲 Worker 从其他工作线程的队列中窃取尚未执行的任务。
- 子任务结果按终止操作的规则合并。
双端队列的两头都能取任务。默认模式下,Worker 从自己这头取最近放进去的任务,窃取者从另一头取较早放进去的任务,减少双方争抢同一位置的机会。递归拆分时,较早放入的任务还可能覆盖更大的范围,窃取它就能一次分担较多工作。
但工作窃取只能重新分配还没开始执行的任务。如果数据拆不下去,或者某个任务正卡在等待网络响应,别的线程也帮不上忙,整体完成时间仍由最慢的那个任务决定。
下面的金额汇总具备独立计算、容易合并的条件,可以作为评估并行收益的例子:
long total = orders.parallelStream()
.filter(Order::confirmed)
.mapToLong(Order::amountInCents)
.sum();
它计算已确认订单的金额总和。每个订单的过滤和取金额都和其他订单无关,不修改任何共享对象,各分区算出部分和,再相加就是总和。即便如此,它也只有在下面几个条件都成立时才真的更快:
- 订单足够多,拆出的任务确实能分担有效工作。
- 节省的计算时间能覆盖拆分、调度和合并的成本。
- 当前进程还有空闲的 CPU 核心。
4. 执行顺序
遇到顺序(encounter order)是数据源或流水线约定的元素顺序,比如 List 的下标顺序。并行流里不同元素的计算会交错进行,但结果仍然可以按遇到顺序排列。先用 forEach 观察一下:
List.of(1, 2, 3, 4)
.parallelStream()
.forEach(System.out::println);
四个数的打印顺序不确定,比如可能是 3 4 1 2,因为 forEach 允许每个任务算完就直接打印。改用 forEachOrdered 后,打印会严格按 1 2 3 4 进行。代价是后面的元素要等前面的打印完,终端动作这一步基本失去了并行。
短路操作也受顺序影响。有序流的 findFirst 必须返回排在最前面的匹配元素,即使别的分区早就找到了,也要等前面的分区确认没有;findAny 则可以直接返回任何一个分区先找到的结果。业务确实不在乎顺序时,可以用 unordered() 去掉这个约束,让执行器有更多选择。
5. 外部可变状态
并行流里的函数如果修改同一个外部对象,就需要处理共享状态的线程安全问题。下面的任务都往同一个 ArrayList 里加元素:
List<String> names = new ArrayList<>();
users.parallelStream()
.map(User::displayName)
.forEach(names::add);
ArrayList 不是线程安全的,多个线程同时 add,结果可能少几个元素、内部数组出现 null,也可能直接抛出 ArrayIndexOutOfBoundsException。换成 Collections.synchronizedList 能保证每次写入安全,但所有线程都要抢同一把锁,而且写入顺序仍不保证与源数据一致。正确的做法是不碰外部容器,让流自己收集结果:
List<String> names = users.parallelStream()
.map(User::displayName)
.toList();
toList() 由流实现管理各分区的结果,调用方不再并发修改同一个 ArrayList。如果 users 有遇到顺序,返回的列表也会保留它。非并发 Collector 则通过分区容器隔离累积过程,最后再合并,规则见 Collector。
共享容器之外,还有几类依赖「当前线程」的东西,换到 Worker 上执行就会出问题:
ThreadLocal的值属于各自的线程。请求线程设置了用户信息、追踪 ID,不代表 Worker 能读到相同的值。- 绑定在当前线程上的事务、安全上下文也一样,不会自动传到 Worker。
SimpleDateFormat这类非线程安全的对象,被多个任务共用就会出错,要么每个任务各用一份,要么加同步。- 外部系统要求按顺序调用时,不能依赖并行
map或forEach的执行顺序;即使用forEachOrdered约束终端动作,这部分动作也需要依次执行。
一条并行流水线由调用线程和多个 Worker 共同执行,有的元素恰好在调用线程上算,ThreadLocal 读得到值。所以测试时偶尔正常,不代表这些问题不存在。
6. 阻塞 I/O
公共池的默认并行度以可用处理器数为依据,适合分担 CPU 计算。如果流水线大部分时间都在等数据库或网络,工作线程就会被阻塞调用占住:
List<Profile> profiles = userIds.parallelStream()
.map(profileClient::load)
.toList();
如果 load 发起阻塞网络请求,执行它的线程就要等响应,期间不能处理其他任务。公共池并不保证能为普通阻塞 I/O 补足线程;大量任务等待时,其他使用者也可能排队。请求持续增加,排队就可能推高尾延迟,也就是最慢一部分请求的耗时,例如第 99 百分位。更麻烦的是,公共池的大小并不是按 profileClient 下游服务的容量设置的。
并发 I/O 需要你明确控制下面这些约束:
- 限制同时发出的请求数,明确最大并发量。
- 配置连接池容量,约束同时使用的外部连接数。
- 设置每次调用与端到端超时,避免请求长期等待。
- 定义取消和异常传播方式,让调用方知道任务是否完成。
- 为不同请求或业务隔离执行资源,减少相互影响。
Java 21 的虚拟线程、有界线程池和异步客户端都可以用来做并发 I/O,选哪个取决于调用方式。不管选哪种,并发数、超时和排队规模都要显式限制,不能超过数据库或远程服务能承受的量。
7. commonPool 竞争
公共 ForkJoinPool 由整个 JVM 进程共享。普通线程发起的并行流,以及通常由公共池执行的 CompletableFuture 默认异步任务,可能竞争同一批工作线程。一个模块提交大量长任务,就会挤占其他模块的执行机会。系统属性 java.util.concurrent.ForkJoinPool.common.parallelism 能调整公共池的并行度,但影响整个进程,不能给某个接口单独设上限。
需要隔离时,应该显式创建执行器来安排任务。也可以把并行流放进自建 ForkJoinPool 的 submit 中执行,但这依赖前面说明的 OpenJDK 行为:在某个池的 Worker 中发起,就使用那个池。Stream API 没有承诺这一点,升级 JDK 时需要重新验证。
并行流 API 未提供队列长度、拒绝策略、业务优先级和请求级并发上限的配置入口。需要过载保护与隔离时,应由业务明确管理执行器及其容量。
8. 适用条件
并行流快不快,取决于并行节省的计算时间能不能盖过额外的拆分、调度和合并成本。下面这些特征有利于获得收益:
- 数据规模足够大,拆分近似均匀。
- 每个元素执行独立的 CPU 计算。
- 计算过程不依赖外部可变状态和线程绑定上下文。
- 合并操作满足结合律,也就是改变括号分组后结果等价,而且合并成本较低。
- 机器有空闲核心,应用允许这项计算使用它们。
下面这些情况会让收益变小,甚至比串行更慢:
- 元素很少或单个操作过轻,调度成本占主导。
- 数据源难以拆分,例如链式结构或串行 I/O。
- 大量装箱、对象分配和全局排序增加了计算与内存开销。
- 有序短路操作限制任务协作。
- 运行环境已经 CPU 饱和。
- 流水线包含数据库、网络或文件阻塞。
这些只是判断方向,最后要靠测量。纯计算部分可以用 Java 微基准工具 JMH 比较串行和并行,再用端到端压测看服务整体的吞吐和尾延迟,数据量、核心数和并发背景都要接近生产。只用 System.currentTimeMillis() 前后各记一次时间,测到的会混进类加载、JIT 即时编译和垃圾回收的耗时,结论不可靠。
9. 异常与取消
某个元素的计算抛出异常,终止操作会把异常抛给调用方,但已经在别的线程上开始执行的任务不一定立刻停下,它们做过的修改也不会回滚。如果函数里有写数据库、发消息这类副作用,调用方看到失败时,部分副作用可能已经发生了。
Stream 也没有超时、部分成功或主动取消的机制。需要这些能力时,要自己组织任务和状态。不要在 Lambda 里把异常一律吞掉再返回 null:失败会混进正常数据里,后面的归约碰到 null 又会抛出新的异常,原始原因反而找不到了。
10. 并行标志与结果顺序
一条流水线只有一种执行模式,结果是否有序则由另一组规则决定。parallel() 和 sequential() 设置的是整条流水线的模式,以最后一次调用为准:
List<Integer> values = IntStream.range(0, 1000)
.parallel()
.map(i -> i * 2)
.sequential()
.boxed()
.toList();
最后调用的是 sequential(),所以包括它前面的 map 在内,整条流水线都串行执行。调用中间操作时只是建立处理阶段,还没有执行 map 中的函数。到了 toList() 才按最终的模式求值,因此不会在 sequential() 所在位置把执行分成两段。
反过来,如果最后是并行模式,有序流的 toList() 照样按遇到顺序返回 0, 2, 4, ...。forEachOrdered 也只约束终端动作的顺序,上游的 map 仍然并发计算。计算同时进行和结果顺序固定,可以同时成立。
unordered() 只是声明「不要求顺序」,不会主动打乱元素。还要注意,并行短路操作找到结果时,其他分区可能已经在算了,所以函数被调用的次数可能比串行时多。流水线里的函数要能接受这种多余的调用,业务逻辑不要依赖调用次数。
11. 常见问题
11.1 parallelStream 使用多少线程?
没有固定的数字。OpenJDK 21 中,公共池的默认目标并行度通常是可用处理器数减一,至少为 1,调用线程也可能参与计算。但任务是否拆得开、公共池有没有其他任务、是否发生阻塞,都会影响实际参与的线程数。目标并行度不等于一次操作固定使用的线程数,也不能充当远程调用的并发上限。
11.2 使用线程安全集合后,业务操作就安全吗?
不一定。线程安全容器保护的是它约定的操作,不能自动保证多个操作组合后的业务规则。「先检查是否存在、再写入」这种两步操作、同时更新两个容器,或者业务上的顺序要求,都需要额外协调。锁竞争还会抵消并行的收益。所以优先用无副作用的转换,让每个分区各自收集,最后合并。
11.3 parallel() 会创建新的线程池吗?
不会。parallel() 只是把流水线的并行标志设为 true,等终止操作执行时,才按并行模式把任务交给线程池。调用终止操作的线程会一直等到最终结果出来,所以并行流也不会让这次调用变成异步的。
11.4 嵌套 parallelStream 会更快吗?
不能据此判断会更快。如果外层已经能利用可用 CPU,内层再并行只会增加拆分、调度和合并成本,内外层还可能竞争同一个线程池。先选择工作量充足、容易均匀拆分的一层做并行,再用基准测试确认收益。
12. 面试题卡片
13. 参考资料
- Java API:Stream 的并行执行说明
- Java API:ForkJoinPool
- Java API:Spliterator
- Java API:BaseStream.parallel
- OpenJDK 21:ForkJoinTask
来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明