ParallelStream并行流在之前文章JAVA8新特性-Stream API中有简单的介绍过它的使用。如Collection集合可以通过parallelStream()的得到一个并行流。

Stream<Integer> stream = new ArrayList<Integer>().parallelStream();

串行流也可以通过parallel()方法转为并行流

Stream<Integer> stream = new ArrayList<Integer>().stream().parallel();

笔者在学习的过程中，也对并行流有着很多的疑问

• 串行流和并行流哪个效率更高？（这还有疑问吗？肯定是并行流呀？sure？）
• 并行流得到的结果是否一定准确？
• 它的实现机制是什么样的？
• 开发中可以使用并行流嘛？

现在就让我们来深入了解一下Java8的这个新特性——并行流

并行流的效率是否更高

在Java8以前，遍历一个长度非常大的集合往往非常麻烦，如需要使用多个线程配合synchronized，Lock和Atomic原子引用等进行遍历，且不说多线程之间的调度，多线程同步API的上手成本也比较高。

现在我们有更为简单的遍历方式，且不局限于遍历集合。

先往一个List添加10万条记录，代码比较简单，单条记录的内容使用UUID随机生成的英文字符串填充

List<String> list = new ArrayList<String>();
for (int i = 0; i < 100000; i++) {
    list.add(UUID.randomUUID().toString());
}

普通for循环该List，然后将每条记录中的a替换成b

for (int i = 0; i < list.size(); i++) {
    String s = list.get(i);
    String replace = s.replace("a", "b");
}

注意：这里使用String replace = s.replace("a", "b");这一行代码作为简单的业务处理，而不是System.out.println(s)，因为打印的时候存在synchronized同步机制，会严重影响并行流的效率！

增强for循环

for (String s : list) {
    String replace = s.replace("a", "b");
}

串行流

list.stream().forEach((s)->{
    String replace = s.replace("a", "b");
});

并行流

list.parallelStream().forEach((s)->{
    String replace = s.replace("a", "b");
});

在保证执行机器一样的情况下，上述遍历代码各执行十次，取执行时间的平均值，单位毫秒，结果如下：

从结果中可知，在数据量较大的情况下，普通for，增强for和串行流的差距并不是很大，而并行流则以肉眼可见的差距领先于另外三者！

数据量较大的情况下，并行流的遍历效率数倍于顺序遍历，在小数据量的情况下，并行流的效率还会那么高吗？

将上面10万的数据量改为1000，然后重复一百次取平均值，结果如下：

对结果进行分析，现在开发中比较少见的普通for遍历集合的方式，居然是顺序遍历中速度最快的！而它的改进版增强for速度小逊于普通for。

究其原因，是增强for内部使用迭代器进行遍历，需要维护ArrayList中的size变量，故而增加了时间开销。

而串行流的时间开销确实有点迷，可能的原因是开启流和关闭流的时间开销比较大

并行流花费的时间仍然优秀于另外的三种遍历方式！

不过，有一点需要注意的是，并行流在执行时，CPU的占用会比另外三者高

现在我们可以得到一个结论，并行流在大数据量时，对比其它的遍历方式有几倍的提升，而在数据量比较小时，提升不明显。

并行流处理结果是否准确

这个准确，举个例子来说，我希望遍历打印一个存有0 1 2 3 4 5 6 7 8 9的list，如0 1 2 3 4 5 6 7 8 9，代码可能会这么写

//数据
List<Integer> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
    list.add(i);
}
//遍历打印
list.stream().forEach(i -> System.out.print(i + " "));

打印的结果如下：

0 1 2 3 4 5 6 7 8 9

结果没有任何问题，如果是并行流呢？遍历代码如下

list.parallelStream().forEach(i -> System.out.print(i + " "));

打印的结果如下：

6 5 1 0 9 3 7 8 2 4 

第二次打印的结果如下：

6 5 0 1 7 9 8 3 4 2 

可以看到打印出来的顺序是混乱无规律的

那是什么原因导致的呢？

并行流内部使用了默认的ForkJoinPool线程池，所以它默认的线程数量就是处理器的数量，通过Runtime.getRuntime().avAIlableProcessors()可以得到这个值。

笔者电脑的线程数是12，这意味着并行流最多可以将任务划分为12个小模块进行处理，然后再合并计算得到结果

如将0~9这是个数字进行划分：

0 1 2 3 4 5 6 7 8 9 
第一次划分得到两个小模块：
0 1 2 3 4  
5 6 7 8 9
第二次划分得到四个小模块：
0 1 2
3 4 
5 6 7
8 9
第三次划分得到八个小模块：
0 1 
2
3 
4
5 6
7
8
9
第三次划分时，2 3 4这些数据，明显已经不能再继续划分，故而2 3 4 这些数据可以先进行打印
第四次划分得到10个小模块：
0
1
2
3
4
5
6
7
8
9
这些小模块在无法继续细分后就会被打印，而打印处理的时候为了提高效率，不分先后顺序，故而造成打印的乱序

结合以上的测试数据，我们可以得到这样一个结论，当需要遍历的数据，存在强顺序性时，不能使用并行流，如顺序打印0~9；不要求顺序性时，可以使用并行流以提高效率，如将集合中的字符串中的"a"替换成"b"

并行流的实现机制

在Java7时，就已经提供了一个并发执行任务的API，Fork/Join，将一个大任务，拆分成若干个小任务， 再将各个小任务的运行结果汇总成最终的结果。

而在java8提供的并行流中，在实现Fork/Join的基础上，还用了工作窃取模式来获取各个小模块的运行结果，使之效率更高！这个知识点笔者后续会另外写一篇文章来介绍，敬请期待。

我们也可以使用Fock/Join机制，模仿一下并行流的实现过程。

如：进行数据的累加

public class ForkJionCalculate extends RecursiveTask<Long> {

    private long start;

    private long end;
 /**
  * 临界值
  */
    private static final long THRESHOLD = 10000L;

    public ForkJionCalculate(long start, long end) {
        this.start = start;
        this.end = end;
    }
    /**
     * 计算方法
     * @return
     */
    @Override
    protected Long compute() {
        long length = end - start;
        if (length <= THRESHOLD) {
            long sum = 0;
            for (long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        } else {
            long middle = (start + end) / 2;
            ForkJionCalculate left = new ForkJionCalculate(start, middle);
            left.fork();//拆分，并将该子任务压入线程队列
            ForkJionCalculate right = new ForkJionCalculate(middle + 1, end);
            right.fork();
            return left.join() + right.join();
        }
    }
}

处理类需要实现RecursiveTask<T>接口，还需指定一个临界值，临界值的作用就是指定将任务拆分到什么程度就不拆了

测试代码：

 public static void main(String[] args) {
     Instant start = Instant.now();
     ForkJoinPool pool = new ForkJoinPool();
     ForkJionCalculate task = new ForkJionCalculate(0, 10000000000L);
     Long sum = pool.invoke(task);
     System.out.println(sum);
     Instant end = Instant.now();
     System.out.println("耗费时间：" + Duration.between(start, end).toMillis());
 }

并行流的适用场景

其实Java这门编程语言其实有很多种用途，通过swing类库可以构建图形用户界面，配合ParallelGC进行一些科学计算任务，不过最广泛的用途，还是作为一门服务器语言，开发服务器应用，我们以这种方式进行测试。

我们使用SpringBoot构建一个工程，然后写一个控制器类，在控制器类中，如上进行1000和10万的数据量测试

另外使用PostMan发送1000并发调用该接口，取平均时间，单位为毫秒值

控制器类测试代码：

@RequestMApping("/parallel")
@ResponseBody
public String parallel() {
    //生成测试数据
    List<String> list = new ArrayList<>();
    for (int i = 0; i < 1000; i++) {
        list.add(UUID.randomUUID().toString());
    }
    //普通for遍历
    for (int i = 0; i < 1000; i++) {
        String s = list.get(i);
        String replace = s.replace("a", "b");
    }
    return "SUCCESS";
}

数据量1000时，每次请求消耗的时间

数据量10W时，每次请求消耗的时间

在之前的测试中，并行流对比其他的遍历方式都有两倍以上的差距，而在并发量较大的情况下，服务器线程本身就处于繁忙的状态，即使使用并行流，优化的空间也不是很大，而且CPU的占用率也会比较高。故而可以看到，并行流在数据量1000或者10万时，提升不是特别明显。

但是并不是说并行流不能用于平常的开发中，如CPU本身的负载不高的情况下，还是可以使用的；在一些定时任务的项目中，为了缩短定时任务的执行时间，也可以斟酌使用。

最后总结一下：在数据量比较大的情况下，CPU负载本身不是很高，不要求顺序执行的时候，可以使用并行流。

来源：
blog.csdn.NET/weixiang2039/article/details/107102364