Java ParallelStream

ParallelStream 处理数据

Stream 接口提供了parallelStream方法来将集合转换为并行流。即将一个集合分为多个数据块,并用不同的线程分别处理每个数据块的流。
并且使用parallelStream 时无需担心内部变量控制,线程数量等问题。
如使用并行流计算1至100000累加之和:

  • 最后一次parallel或sequential调用会影响整个流水线,即如下例子中会并行执行。
  • parallelStream使用得默认核心数为Runtime.getRuntime().availableProcessors() - 1。
    可通过配置java.util.concurrent.ForkJoinPool.common.parallelism改变默认的核心数。
        Stream.iterate(1L, param1 -> Math.addExact(param1, 1))
                .limit(100000)
                .parallel()
                .sequential()
                .parallel()
                .reduce(0L, Math::addExact)
                .longValue();

parallelStream 性能分析

通常我们认为在数据量到达一定程度时,使用多线程计算会获得更好的性能。但实际效果应该在测量比较之后才直到。
使用并行流和顺序流别计算1至100000 的累加之和,在我的四核英特尔机器上运行结果如下:

        long start = System.currentTimeMillis();
        Stream.iterate(1L, param1 -> Math.addExact(param1, 1))
                .limit(100000)
                .parallel()
                .reduce(0L, Math::addExact)
                .longValue();
        System.out.println(String.format("Parallel accumulate sum, used %d ms.", System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        LongStream.rangeClosed(1, 100000)
                    .reduce(0L, Math::addExact);
        System.out.println(String.format("Sequential accumulate sum, used %d ms.", System.currentTimeMillis() - start));
      
      Parallel accumulate sum, used 64 ms.
      Sequential accumulate sum, used 8 ms.

通过以上结果可以看到,并行流计算的耗时竟然是顺序流的好几倍,这与我们的预期结果差距十分的大。
要想明白这差距的原因,首先得明白影响上面并行流的速度的因素有那些:

  • 元素是否容易拆分为多个数据块, 很明显Iterate 很难拆分为多个独立数据块,因为每次应用这个函数都要依赖于前一个元素。
  • 元素是否频繁拆装箱, 流中Long -> long 频繁拆装箱也影响了效率。而LongStream 中并没有这个消耗。

修复上面两个影响并行流的速度的问题后,重新运行结果如下:


        long start = System.currentTimeMillis();
        LongStream.rangeClosed(1, 100000)
                    .parallel()
                    .reduce(0L, Math::addExact);
        System.out.println(String.format("Parallel accumulate sum, used %d ms.", System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        LongStream.rangeClosed(1, 100000)
                    .reduce(0L, Math::addExact);
        System.out.println(String.format("Sequential accumulate sum, used %d ms.", System.currentTimeMillis() - start));

        Parallel accumulate sum, used 7 ms.
        Sequential accumulate sum, used 3 ms.

并行流的速度得到了很大提升,这表明并行化时需要使用正确的数据结构
但是顺序流的速度却仍然更快,这说明并行化也是有代价的,如下:

  • 内核之间交换数据的花销较大。
  • 要保证在内核中的处理时间大于内核间的数据交换时间,即数据到达一定的量级。

而并行过程需要对流要递归划分,再把每个子流的归纳操作分配到不同的线程,最后把这些操作的结果合并成一个值。
在子流归纳操作时间过短时,并行化并没有带来性能提升,反而是更加慢了。

再将数据提升至上亿级别进行运算,并行流终于取得了一些领先。

        long start = System.currentTimeMillis();
        LongStream.rangeClosed(1, 100000000)
                    .parallel()
                    .reduce(0L, Math::addExact);
        System.out.println(String.format("Parallel accumulate sum, used %d ms.", System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        LongStream.rangeClosed(1, 100000000)
                    .reduce(0L, Math::addExact);
        System.out.println(String.format("Sequential accumulate sum, used %d ms.", System.currentTimeMillis() - start));
        Parallel accumulate sum, used 79 ms.
        Sequential accumulate sum, used 264 ms.

高效使用ParallelStream

关于在什么地方使用parallelStream 没有绝对的建议,而是只能做定性分析。下列是一些可能影响性能的地方:

  • 测量比较,并行流并不都比顺序流快。
  • 避免拆装箱,这对性能有较大影响。可使用原始类型IntStream, LongStream等。
  • 依赖元素顺序的操作,并行性能较差。如findAny()性能会优于findFirst(),因为它不依赖于顺序。
  • 数据量大小,估算一个元素通过流水线的大概处理时间,得到处理完整个集合的处理时间。
  • 流是否易于拆分,如ArrayList 比LinkedList 更易于拆分,前者无需遍历,后者需要遍历之后才能拆分。
  • 终端操作时,合并操作的代价大小(例如Collector中的combiner方法)。

Fork/Join

ParallelStream流背后使用的基础架构是Java 7中引入的Fork/Join分支合并框架。
分支/合并框架的目的是以递归方式将可以并行的任务拆分成更小的任务,然后将每个子任务的结果合并起来生成整体结果。
这其实就是分治算法的并行版本。

上一篇:通过阿里云服务器的公网IP访问django网站


下一篇:(三种方法)求解一维前缀和