Java8新特性之parallelStream详解

一、什么是流？

Stream是java8中新增加的一个特性，首先Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator。原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等，Stream 会隐式地在内部进行遍历，做出相应的数据转换。

Stream 就如同一个迭代器（Iterator），单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了，就好比流水从面前流过，一去不复返。而和迭代器又不同的是，Stream 可以并行化操作，迭代器只能命令式地、串行化操作。顾名思义，当使用串行方式去遍历时，每个 item 读完后再读下一个 item。而使用并行去遍历时，数据会被分成多个段，其中每一个都在不同的线程中处理，然后将结果一起输出。Stream 的并行操作依赖于 Java7 中引入的 Fork/Join 框架（JSR166y）来拆分任务和加速处理过程。

Java 的并行 API 演变历程基本如下：

1.0-1.4 中的 java.lang.Thread  
5.0 中的 java.util.concurrent  
6.0 中的 Phasers 等  
7.0 中的 Fork/Join 框架  
8.0 中的 Lambda  

Stream 的另外一大特点是，数据源本身可以是无限的。

二、parallelStream是什么

parallelStream其实就是一个并行执行的流.它通过默认的ForkJoinPool,可能提高你的多线程任务的速度.

parallelStream的作用：Stream具有平行处理能力，处理的过程会分而治之，也就是将一个大任务切分成多个小任务，这表示每个任务都是一个操作，因此像以下的程式片段：

  1.  
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
  2.  
    numbers.parallelStream().forEach(out::println);

你得到的展示顺序不一定会是1、2、3、4、5、6、7、8、9，而可能是任意的顺序，就forEach()这个操作來讲，如果平行处理时，希望最后顺序是按照原来Stream的数据顺序，那可以调用forEachOrdered()。例如：

  1.  
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
  2.  
    numbers.parallelStream().forEachOrdered(out::println);

注意:如果forEachOrdered()中间有其他如filter()的中介操作，会试着平行化处理，然后最终forEachOrdered()会以原数据顺序处理，因此，使用forEachOrdered()这类的有序处理,可能会（或完全失去）失去平行化的一些优势，实际上中介操作亦有可能如此，例如sorted()方法。

三、parallelStream原理——ForkJoinPool

要想深入的研究parallelStream之前,那么我们必须先了解ForkJoin框架和ForkJoinPool.本文旨在parallelStream,但因为两种关系甚密,故在此简单介绍一下ForkJoinPool,如有兴趣可以更深入的去了解下ForkJoin(当然,如果你想真正的搞透parallelStream,那么你依然需要先搞透ForkJoinPool).

ForkJoin框架是从jdk7中新特性,它同ThreadPoolExecutor一样，也实现了Executor和ExecutorService接口。它使用了一个无限队列来保存需要执行的任务，而线程的数量则是通过构造函数传入，如果没有向构造函数中传入希望的线程数量，那么当前计算机可用的CPU数量会被设置为线程数量作为默认值。

ForkJoinPool主要用来使用分治法(Divide-and-Conquer Algorithm)来解决问题。典型的应用比如快速排序算法。这里的要点在于，ForkJoinPool需要使用相对少的线程来处理大量的任务。比如要对1000万个数据进行排序，那么会将这个任务分割成两个500万的排序任务和一个针对这两组500万数据的合并任务。以此类推，对于500万的数据也会做出同样的分割处理，到最后会设置一个阈值来规定当数据规模到多少时，停止这样的分割处理。比如，当元素的数量小于10时，会停止分割，转而使用插入排序对它们进行排序。那么到最后，所有的任务加起来会有大概2000000+个。问题的关键在于，对于一个任务而言，只有当它所有的子任务完成之后，它才能够被执行。

所以当使用ThreadPoolExecutor时，使用分治法会存在问题，因为ThreadPoolExecutor中的线程无法像任务队列中再添加一个任务并且在等待该任务完成之后再继续执行。而使用ForkJoinPool时，就能够让其中的线程创建新的任务，并挂起当前的任务，此时线程就能够从队列中选择子任务执行。

那么使用ThreadPoolExecutor或者ForkJoinPool，会有什么性能的差异呢？ 
首先，使用ForkJoinPool能够使用数量有限的线程来完成非常多的具有父子关系的任务，比如使用4个线程来完成超过200万个任务。但是，使用ThreadPoolExecutor时，是不可能完成的，因为ThreadPoolExecutor中的Thread无法选择优先执行子任务，需要完成200万个具有父子关系的任务时，也需要200万个线程，显然这是不可行的。

工作窃取算法

forkjoin最核心的地方就是利用了现代硬件设备多核,在一个操作时候会有空闲的cpu,那么如何利用好这个空闲的cpu就成了提高性能的关键,而这里我们要提到的工作窃取（work-stealing）算法就是整个forkjion框架的核心理念,工作窃取（work-stealing）算法是指某个线程从其他队列里窃取任务来执行。

那么为什么需要使用工作窃取算法呢？

假如我们需要做一个比较大的任务，我们可以把这个任务分割为若干互不依赖的子任务，为了减少线程间的竞争，于是把这些子任务分别放到不同的队列里，并为每个队列创建一个单独的线程来执行队列里的任务，线程和队列一一对应，比如A线程负责处理A队列里的任务。但是有的线程会先把自己队列里的任务干完，而其他线程对应的队列里还有任务等待处理。干完活的线程与其等着，不如去帮其他线程干活，于是它就去其他线程的队列里窃取一个任务来执行。而在这时它们会访问同一个队列，所以为了减少窃取任务线程和被窃取任务线程之间的竞争，通常会使用双端队列，被窃取任务线程永远从双端队列的头部拿任务执行，而窃取任务的线程永远从双端队列的尾部拿任务执行。

工作窃取算法的优点是充分利用线程进行并行计算，并减少了线程间的竞争，其缺点是在某些情况下还是存在竞争，比如双端队列里只有一个任务时。并且消耗了更多的系统资源，比如创建多个线程和多个双端队列。

 

三、用看forkjion的眼光来看ParallelStreams

上文中已经提到了在Java 8引入了自动并行化的概念。它能够让一部分Java代码自动地以并行的方式执行，也就是我们使用了ForkJoinPool的ParallelStream。

Java 8为ForkJoinPool添加了一个通用线程池，这个线程池用来处理那些没有被显式提交到任何线程池的任务。它是ForkJoinPool类型上的一个静态元素，它拥有的默认线程数量等于运行计算机上的处理器数量。当调用Arrays类上添加的新方法时，自动并行化就会发生。比如用来排序一个数组的并行快速排序，用来对一个数组中的元素进行并行遍历。自动并行化也被运用在Java 8新添加的Stream API中。

比如下面的代码用来遍历列表中的元素并执行需要的操作：

  1.  
        List<UserInfo> userInfoList =
  2.  
            DaoContainers.getUserInfoDAO().queryAllByList(new UserInfoModel());
  3.  
        userInfoList.parallelStream().forEach(RedisUserApi::setUserIdUserInfo);

对于列表中的元素的操作都会以并行的方式执行。forEach方法会为每个元素的计算操作创建一个任务，该任务会被前文中提到的ForkJoinPool中的通用线程池处理。以上的并行计算逻辑当然也可以使用ThreadPoolExecutor完成，但是就代码的可读性和代码量而言，使用ForkJoinPool明显更胜一筹。

对于ForkJoinPool通用线程池的线程数量，通常使用默认值就可以了，即运行时计算机的处理器数量。我这里提供了一个示例的代码让你了解jvm所使用的ForkJoinPool的线程数量, 你可以可以通过设置系统属性：

-Djava.util.concurrent.ForkJoinPool.common.parallelism=N （N为线程数量）

通过调整ForkJoinPool的线程数量,可以尝试调整成不同的参数来观察每次的输出结果:

  1.  
    import java.util.ArrayList;
  2.  
    import java.util.List;
  3.  
    import java.util.Set;
  4.  
    import java.util.concurrent.CopyOnWriteArraySet;
  5.  
    import java.util.concurrent.CountDownLatch;
  6.  
     
  7.  
    /**
  8.  
    * @description 这是一个用来让你更加熟悉parallelStream的原理的实力
  9.  
    * @date 2016年10月11日18:26:55
  10.  
    * @version v1.0
  11.  
    * @author wangguangdong
  12.  
    */
  13.  
    public class App {
  14.  
    public static void main(String[] args) throws Exception {
  15.  
    System.out.println("Hello World!");
  16.  
    // 构造一个10000个元素的集合
  17.  
    List<Integer> list = new ArrayList<>();
  18.  
    for (int i = 0; i < 10000; i++) {
  19.  
    list.add(i);
  20.  
    }
  21.  
    // 统计并行执行list的线程
  22.  
    Set<Thread> threadSet = new CopyOnWriteArraySet<>();
  23.  
    // 并行执行
  24.  
    list.parallelStream().forEach(integer -> {
  25.  
    Thread thread = Thread.currentThread();
  26.  
    // System.out.println(thread);
  27.  
    // 统计并行执行list的线程
  28.  
    threadSet.add(thread);
  29.  
    });
  30.  
    System.out.println("threadSet一共有" + threadSet.size() + "个线程");
  31.  
    System.out.println("系统一个有"+Runtime.getRuntime().availableProcessors()+"个cpu");
  32.  
    List<Integer> list1 = new ArrayList<>();
  33.  
    List<Integer> list2 = new ArrayList<>();
  34.  
    for (int i = 0; i < 100000; i++) {
  35.  
    list1.add(i);
  36.  
    list2.add(i);
  37.  
    }
  38.  
    Set<Thread> threadSetTwo = new CopyOnWriteArraySet<>();
  39.  
    CountDownLatch countDownLatch = new CountDownLatch(2);
  40.  
    Thread threadA = new Thread(() -> {
  41.  
    list1.parallelStream().forEach(integer -> {
  42.  
    Thread thread = Thread.currentThread();
  43.  
    // System.out.println("list1" + thread);
  44.  
    threadSetTwo.add(thread);
  45.  
    });
  46.  
    countDownLatch.countDown();
  47.  
    });
  48.  
    Thread threadB = new Thread(() -> {
  49.  
    list2.parallelStream().forEach(integer -> {
  50.  
    Thread thread = Thread.currentThread();
  51.  
    // System.out.println("list2" + thread);
  52.  
    threadSetTwo.add(thread);
  53.  
    });
  54.  
    countDownLatch.countDown();
  55.  
    });
  56.  
     
  57.  
    threadA.start();
  58.  
    threadB.start();
  59.  
    countDownLatch.await();
  60.  
    System.out.print("threadSetTwo一共有" + threadSetTwo.size() + "个线程");
  61.  
     
  62.  
    System.out.println("---------------------------");
  63.  
    System.out.println(threadSet);
  64.  
    System.out.println(threadSetTwo);
  65.  
    System.out.println("---------------------------");
  66.  
    threadSetTwo.addAll(threadSet);
  67.  
    System.out.println(threadSetTwo);
  68.  
    System.out.println("threadSetTwo一共有" + threadSetTwo.size() + "个线程");
  69.  
    System.out.println("系统一个有"+Runtime.getRuntime().availableProcessors()+"个cpu");
  70.  
    }
  71.  
    }

转自：https://blog.csdn.net/lixinkuan328/article/details/103775285

参考：https://www.javaroad.cn/questions/29666

posted @ 2023-07-12 14:00  甜菜波波  阅读(2145)  评论(0)  编辑  收藏  举报