JavaSE Stream 是否线程安全？并行流又是什么？

Java 8 引入的 Stream API 是 Java 集合操作的一大革新，它提供了声明式的流式处理方式，极大地方便了数据处理。但在使用 Stream 时，一个常见的问题是：Stream 是线程安全的吗？ 此外，Stream 还有一个"并行流"（Parallel Stream）的概念，这又是什么？本文将循序渐进地分析这些问题，带你深入理解 Stream 的线程安全性和并行流的原理。

第一步：什么是 Stream？

在 Java 中，java.util.stream.Stream 是一个接口，用于从数据源（如集合、数组等）中创建流，然后通过一系列操作（如 filter、map、reduce 等）处理数据。Stream 的核心特点是：

惰性求值 ：只有在终端操作（如 collect、forEach）被调用时，流才会真正执行。
一次性使用 ：一个 Stream 对象只能被消费一次，重复使用会抛出 IllegalStateException。
内部迭代：不像传统的外部迭代（for 循环），Stream 使用内部迭代，由 API 控制执行逻辑。

例如：

java 复制代码

List<String> list = Arrays.asList("apple", "banana", "cherry");
list.stream()
    .filter(s -> s.startsWith("a"))
    .forEach(System.out::println); // 输出：apple

这只是 Stream 的基本用法，但线程安全性如何呢？我们逐步分析。

第二步：Stream 是线程安全的吗？

要判断 Stream 是否线程安全，我们需要明确"线程安全"的定义：一个对象或操作在多线程环境下使用时，如果不需要额外的同步措施就能保证数据一致性和正确性，那么它就是线程安全的。

普通流（顺序流）的线程安全性

默认情况下，list.stream() 创建的是顺序流（Sequential Stream）。它的执行是单线程的，所有的操作都在调用线程中完成。从这个角度看，顺序流本身是线程安全的------前提是只有一个线程在使用它。

但问题在于：如果多个线程同时操作同一个 Stream 对象会怎样？答案是：Stream 不是为并发访问设计的。

一次性使用的限制 ：Stream 只能被消费一次。如果多个线程尝试对同一个 Stream 调用终端操作，会抛出 IllegalStateException，例如"stream has already been operated upon or closed"。
内部状态不可预测：Stream 的内部实现依赖于 Spliterator（分割迭代器），它的状态在流操作过程中会发生变化。如果多个线程同时操作，状态可能会出现竞争条件，导致不可预期的结果。

示例代码展示问题：

java 复制代码

List<String> list = Arrays.asList("apple", "banana", "cherry");
Stream<String> stream = list.stream();

Thread t1 = new Thread(() -> stream.forEach(System.out::println));
Thread t2 = new Thread(() -> stream.forEach(System.out::println));

t1.start();
t2.start();

运行这段代码，很可能会抛出异常，因为 stream 已经被一个线程消费，另一个线程再操作时会失败。即使不抛异常，结果也可能混乱，因为 Stream 的设计不考虑多线程并发访问。

数据源的线程安全性

即使 Stream 本身不被多个线程直接操作，数据源（例如底层的 List）也可能引发线程安全问题。如果数据源在流操作期间被其他线程修改，结果将是不可预期的。例如：

java 复制代码

List<String> list = new ArrayList<>(Arrays.asList("apple", "banana"));
Stream<String> stream = list.stream();

new Thread(() -> list.add("cherry")).start();
stream.forEach(System.out::println); // 可能输出 apple, banana，也可能包含 cherry

在上面的例子中，ArrayList 不是线程安全的，流操作期间的修改可能导致 ConcurrentModificationException 或不一致的结果。

结论：普通流（顺序流）在单线程使用时是安全的，但它本身不具备线程安全保证。如果多个线程操作同一个 Stream 或数据源未同步，则可能导致异常或错误。因此，Stream 不是线程安全的 ，除非你通过外部同步（如 synchronized 或使用线程安全的集合）来保证安全。

第三步：什么是并行流？

Java Stream API 提供了 parallelStream() 方法，或者通过 stream().parallel() 将普通流转换为并行流。并行流利用多线程并行处理数据，旨在提高性能，尤其是在处理大数据集时。

例如：

java 复制代码

List<String> list = Arrays.asList("apple", "banana", "cherry");
list.parallelStream()
    .filter(s -> s.startsWith("a"))
    .forEach(System.out::println); // 输出顺序可能是乱的，但结果包含 apple

并行流的核心是基于 Fork/Join 框架 ，它会将任务分割成小块，分配给线程池（默认是 ForkJoinPool.commonPool()）中的多个线程执行。

并行流的线程安全性

并行流看起来像是多线程操作，那它是否线程安全呢？答案需要分情况讨论：

数据源的线程安全性：
- 并行流假设数据源在操作期间不会被外部修改。如果底层集合（如 ArrayList）不是线程安全的，且在并行流执行期间被修改，结果会不一致甚至抛出异常。
- 使用线程安全的数据源（如 CopyOnWriteArrayList）可以避免这个问题，但这会带来性能开销。
操作的线程安全性：
- 并行流会将操作分发给多个线程执行。如果中间操作或终端操作有副作用（例如修改共享变量），可能导致竞争条件。
- 示例：
  java 复制代码
```
List<String> list = Arrays.asList("apple", "banana", "cherry");
int[] count = {0}; // 共享变量
list.parallelStream().forEach(s -> count[0]++); // 可能导致 count 值不准确
System.out.println(count[0]); // 期望 3，但可能是 1、2 或 3
```
  在并行流中，count[0] 被多个线程并发修改，没有同步措施，结果不可预测。
无状态操作是安全的：
- 如果流的每个操作是无状态的（stateless，例如 filter、map）且没有副作用，并行流是安全的。例如：
  java 复制代码
```
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
long sum = numbers.parallelStream()
                 .map(n -> n * 2)
                 .reduce(0, Integer::sum);
System.out.println(sum); // 始终输出 30
```
  这里 map 和 reduce 都是无状态且无副作用的，线程之间互不干扰，结果始终正确。

并行流的线程安全性结论：

并行流本身通过 Fork/Join 框架管理线程分配和任务分割，在无副作用的情况下是线程安全的。
但如果数据源非线程安全，或操作涉及共享状态（如变量修改），需要开发者自行确保同步，否则并行流可能导致数据竞争或不一致。

第四步：如何安全使用 Stream？

基于以上分析，我们可以总结出使用 Stream 和并行流的几条最佳实践：

顺序流：
- 确保只在单线程中使用 Stream。
- 如果数据源可能被多线程修改，使用 Collections.synchronizedList() 或其他线程安全集合。
并行流：
- 仅在数据量大且计算密集时使用并行流，小数据集可能因线程开销得不偿失。
- 避免在并行流中操作共享变量。如果需要累积结果，使用 reduce 或 collect 等线程安全操作。
- 使用线程安全的数据源（如 CopyOnWriteArrayList）或确保数据源在流操作期间不被修改。

示例（线程安全的并行流）：

java 复制代码

List<Integer> numbers = Collections.synchronizedList(Arrays.asList(1, 2, 3, 4, 5));
int sum = numbers.parallelStream()
                 .map(n -> n * 2)
                 .reduce(0, Integer::sum);
System.out.println(sum); // 始终输出 30

总结

Stream 是否线程安全？
- 普通流（顺序流）在单线程使用时是安全的，但在多线程环境下不是线程安全的。
- 需要外部同步来保证线程安全。
并行流是什么？
- 并行流是利用多线程并行处理数据的流实现，基于 Fork/Join 框架。
- 在无副作用和数据源稳定的情况下是线程安全的，但操作共享状态时需要特别注意。

Stream API 的强大之处在于其简洁性和表达力，但线程安全性完全取决于使用方式。理解其设计原理并遵循最佳实践，才能在开发中充分发挥其优势。