JUC 高并发编程(10)：Fork/join 架构

Fork/join

概述

从JDK1.7开始，Java提供 Fork/Join框架 用于并行执行任务，它的思想就是将一个大任务分割成若干小任务，最终汇总每个小任务的结果得到这个大任务的结果。

• 这种思想和MapReduce很像（input --> split --> map --> reduce --> output）
  

主要有两步：

• 第一、任务切分；
• 第二、结果合并

它的模型大致是这样的：线程池中的每个线程都有自己的工作队列
（PS：这一点和ThreadPoolExecutor不同，ThreadPoolExecutor是所有线程公用一个工作队列，所有线程都从这个工作队列中取任务），当自己队列中的任务都完成以后，会从其它线程的工作队列中偷一个任务执行，这样可以充分利用资源。

传统分支编程的弊端

分治的原理就是切割大任务成小任务来完成。看起来好像也不难实现啊！为什么专门弄一个新的框架呢？
我们先看一下，在不使用 Fork-Join 框架时，使用普通的线程池是怎么实现的。

• 我们往一个线程池提交了一个大任务，规定好任务切割的阀值。
• 由线程池中线程（假设是线程A）执行大任务，发现大任务的大小大于阀值，于是切割成两个子任务，并调用 submit() 提交到线程池，得到返回的子任务的 Future。
• 线程A就调用 返回的 Future 的 get() 方法阻塞等待子任务的执行结果。
• 池中的其他线程（除线程A外，线程A被阻塞）执行两个子任务，然后判断子任务的大小有没有超过阀值，如果超过，则按照步骤2继续切割，否则，才计算并返回结果。

咦，好像一切都很美好。真的吗？别忘了， 每一个切割任务的线程（如线程A）都被阻塞了，直到其子任务完成，才能继续往下运行 。

• 如果任务太大了，需要切割多次，那么就会有多个线程被阻塞，性能将会急速下降。更糟糕的是，如果你的线程池的线程数量是有上限的，极可能会造成池中所有线程被阻塞，线程池无法执行任务。

• 代码如下：

  public class CountTest {
      public static void main(String[] args) throws InterruptedException, ExecutionException {
  
          ForkJoinPool forkJoinPool = new ForkJoinPool();
          //创建一个计算任务，计算 由1加到12
          CountTask countTask = new CountTask(1, 12);
          Future<Integer> future = forkJoinPool.submit(countTask);
          System.out.println("最终的计算结果：" + future.get());
      }
  }
  
  class CountTask extends RecursiveTask<Integer> {
  
      private static final int THRESHOLD = 2;
      private int start;
      private int end;
  
  
      public CountTask(int start, int end) {
          this.start = start;
          this.end = end;
      }
  
      @Override
      protected Integer compute() {
          int sum = 0;
          boolean canCompute = (end - start) <= THRESHOLD;
  
          //任务已经足够小，可以直接计算，并返回结果
          if (canCompute) {
              for (int i = start; i <= end; i++) {
                  sum += i;
              }
              System.out.println("执行计算任务，计算    " + start + "到 " + end + "的和  ，结果是：" + sum + "   执行此任务的线程：" + Thread.currentThread().getName());
              return sum;
          } else { //任务过大，需要切割
              System.out.println("任务过大，切割的任务：  " + start + "加到 " + end + "的和       执行此任务的线程：" + Thread.currentThread().getName());
              int middle = (start + end) / 2;
              //切割成两个子任务
              CountTask leftTask = new CountTask(start, middle);
              CountTask rightTask = new CountTask(middle + 1, end);
              //执行子任务
              leftTask.fork();
              rightTask.fork();
              //等待子任务的完成，并获取执行结果
              invokeAll(leftTask,rightTask);
  //            int leftResult = leftTask.join();
  //            int rightResult = rightTask.join();
              //合并子任务
  //            sum = leftResult + rightResult;
  //            return sum;
              return leftTask.join()+rightTask.join();
          }
  
      }
  }
  
  

• 运行结果:

  切割的任务：1加到10   执行此任务的线程是 pool-1-thread-1
  切割的任务：1加到5   执行此任务的线程是 pool-1-thread-2
  切割的任务：6加到10   执行此任务的线程是 pool-1-thread-3
  

  池的线程只有三个，当任务分割了三次后，池中的线程也就都被阻塞了，无法再执行任何任务，一直卡着动不了。为了解决这个问题,工作窃取算法呼之欲出

工作窃取（work-stealing）算法

工作窃取（work-stealing）算法是指某个线程从其他队列里窃取任务来执行。工作窃取的运行流程图如下：

在《Java 并发编程的艺术》对工作窃取算法的解释：

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

具体步骤：

• Fork-Join 框架的线程池 ForkJoinPool 的任务分为“外部任务” 和 “内部任务”。
• “外部任务”是放在 ForkJoinPool 的全局队列里；
• ForkJoinPool 池中的每个线程都维护着一个内部队列，用于存放“内部任务”。
• 线程切割任务得到的子任务就会作为“内部任务”放到内部队列中。
• 当此线程要想要拿到子任务的计算结果时，先判断子任务有没有完成，如果没有完成，则再判断子任务有没有被其他线程“窃取”，一旦子任务被窃取了则去执行本线程“内部队列”的其他任务，或者扫描其他的任务队列，窃取任务，如果子任务没有被窃取，则由本线程来完成。
• 最后，当线程完成了其“内部任务”，处于空闲的状态时，就会去扫描其他的任务队列，窃取任务

工作窃取算法优缺点：

• 优点：充分利用线程进行并行计算，减少线程间的竞争
• 缺点：消耗更多系统资源，只有一个任务时会出现竞争

Fork-join 框架的使用

Fork/Join有三个核心类：

• ForkJoinPool： 执行任务的线程池，继承了 AbstractExecutorService 类。

• ForkJoinWorkerThread： 执行任务的工作线程（即ForkJoinPool线程池里的线程）。每个线程都维护着一个内部队列，用于存放“内部任务”。继承了 Thread 类。

• ForkJoinTask： 一个用于ForkJoinPool的任务抽象类。实现了 Future 接口
  因为 ForkJoinTask 比较复杂，抽象方法比较多，日常使用时一般不会继承ForkJoinTask来实现自定义的任务，而是继承ForkJoinTask的两个子类，实现 compute() 方法：

  • RecursiveTask： 子任务带返回结果时使用
  • RecursiveAction： 子任务不带返回结果时使用

• compute 方法的实现模式一般是：

  if 任务足够小
      直接返回结果
  else
      分割成N个子任务
      依次调用每个子任务的fork方法执行子任务
      依次调用每个子任务的join方法合并执行结果
  
  

Fork-Join 例子演示1 :利用 RecursiveTask 计算 1+2+…+12 的结果。

• 使用Fork／Join框架首先要考虑到的是如何分割任务，如果我们希望每个子任务最多执行两个数的相加，那么我们设置分割的阈值是2，由于是12个数字相加。同时，观察执行任务的线程名称，理解工作窃取算法的实现。

  public class CountTest {
      public static void main(String[] args) throws InterruptedException, ExecutionException {
  
          ForkJoinPool forkJoinPool = new ForkJoinPool();
          //创建一个计算任务，计算 由1加到12
          CountTask countTask = new CountTask(1, 12);
          // 提交任务
          Future<Integer> future = forkJoinPool.submit(countTask);
          System.out.println("最终的计算结果：" + future.get());
      }
  }
  
  class CountTask extends RecursiveTask<Integer> {
  	//设置阈值
      private static final int THRESHOLD = 2;
      private int start;
      private int end;
  
  
      public CountTask(int start, int end) {
          this.start = start;
          this.end = end;
      }
  	//实现compute 方法，将任务的具体操作进行实现
      @Override
      protected Integer compute() {
          int sum = 0;
          //判断此时与阈值之间的关系
          boolean canCompute = (end - start) <= THRESHOLD;
  
          //任务已经足够小，可以直接计算，并返回结果
          if (canCompute) {
              for (int i = start; i <= end; i++) {
                  sum += i;
              }
              System.out.println("执行计算任务，计算    " + start + "到 " + end + "的和  ，结果是：" + sum + "   执行此任务的线程：" + Thread.currentThread().getName());
  
          } else { //任务过大，需要切割
              System.out.println("任务过大，切割的任务：  " + start + "加到 " + end + "的和       执行此任务的线程：" + Thread.currentThread().getName());
              int middle = (start + end) / 2;
              //切割成两个子任务
              CountTask leftTask = new CountTask(start, middle);
              CountTask rightTask = new CountTask(middle + 1, end);
              //执行子任务
              leftTask.fork();
              rightTask.fork();
              //等待子任务的完成，并获取执行结果
              int leftResult = leftTask.join();
              int rightResult = rightTask.join();
              //合并子任务
              sum = leftResult + rightResult;
          }
          return sum;
      }
  }
  
  

• 结果显示：

  任务过大，切割的任务： 1加到 12的和 执行此任务的线程：ForkJoinPool-1-worker-1
  任务过大，切割的任务： 7加到 12的和 执行此任务的线程：ForkJoinPool-1-worker-3
  任务过大，切割的任务： 1加到 6的和 执行此任务的线程：ForkJoinPool-1-worker-2
  执行计算任务，计算 7到 9的和 ，结果是：24 执行此任务的线程：ForkJoinPool-1-worker-3
  执行计算任务，计算 1到 3的和 ，结果是：6 执行此任务的线程：ForkJoinPool-1-worker-1
  执行计算任务，计算 4到 6的和 ，结果是：15 执行此任务的线程：ForkJoinPool-1-worker-1
  执行计算任务，计算 10到 12的和 ，结果是：33 执行此任务的线程：ForkJoinPool-1-worker-3
  最终的计算结果：78
  
  

Fork-Join 例子演示2 :利用 RecursiveAction 遍历指定目录（含子目录）找寻指定类型文件

• 代码如下

  public class FindDirsFiles extends RecursiveAction{
  
      /**
       * 当前任务需要搜寻的目录
       */
      private File path;
  
      public FindDirsFiles(File path) {
          this.path = path;
      }
  
      public static void main(String [] args){
          try {
              // 用一个 ForkJoinPool 实例调度总任务
              ForkJoinPool pool = new ForkJoinPool();
              FindDirsFiles task = new FindDirsFiles(new File("D:/"));
  
              //异步调用
              pool.execute(task);
  
              System.out.println("Task is Running......");
              Thread.sleep(1);
              int otherWork = 0;
              for(int i=0;i<1000000;i++){
                  otherWork = otherWork+i;
              }
              System.out.println("Main Thread done sth......,otherWork=" + otherWork);
              //阻塞的方法
              task.join();
              System.out.println("Task end");
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  
  	@Override
  	protected void compute() {
  		
  		List<FindDirsFiles> subTasks = new ArrayList<>();
  		
  		File[] files = path.listFiles();
  		if(files!=null) {
  			for(File file:files) {
  				if(file.isDirectory()) {
  					subTasks.add(new FindDirsFiles(file));
  				}else {
  					//遇到文件，检查
  					if(file.getAbsolutePath().endsWith("txt")) {
  						System.out.println("文件："+file.getAbsolutePath());
  					}
  				}
  			}
  			if(!subTasks.isEmpty()) {
                  for (FindDirsFiles subTask : invokeAll(subTasks)) {
                      //等待子任务执行完成
                      subTask.join();
                  }
  			}
  		}
  
  
  		
  	}
  }
  
  
  

ForkJoinPool 的源码解析

ForkJoinPool 与其它的 ExecutorService 区别主要在于它使用 “工作窃取” 。

WorkQueue 是一个ForkJoinPool中的内部类，它是线程池中线程的工作队列的一个封装，支持任务窃取。

• 如果存在执行2个任务的子线程，就可以看成存在 A,B两个 WorkQueue在执行任务，A的任务执行完了，B的任务没执行完，那么A的WorkQueue就从B的WorkQueue的ForkJoinTask 数组中拿走了一部分尾部的任务来执行，可以合理的提高运行和计算效率。工作窃取得到基本原理

• WorkQueue 的具体结构如下：
  

• WorkQueue主要中有两个数组（array 与 owner）：任务数组ForkJoinTask和工作线程数组ForkJoinWorkerThread

  • ForkJoinTask 负责存放提交的任务
  • ForkJoinWorkerThread 负责执行这些任务
    

任务提交

• 继承 RecursiveTask 则用 submit 提交任务，可以看到下面源代码中，会有一个返回值
  

• 继承 RecursiveAction 的线程池 则利用 excute 提交任务：
  

• 实际上，这两种方法都调用了 externalPush 将传入的任务提交到线程池
  

• 同样是提交任务，submit 会返回 ForkJoinTask ，而execute不会

• 任务提交给线程池以后，会将这个任务加入到当前提交者的任务队列中。

• 该任务就会提交到 任务数组 array 中

ForkJoinWorkerThread

从代码中我们可以清楚地看到，ForkJoinWorkThread 持有 ForkJoinPool 和ForkJoinPool.WorkQueue 的引用，以表明该线程属于哪个线程池，它的工作队列是哪个

ForkJoinTask

• fork()： 把当前任务push 到当前线程的工作队列的头部，即希望它开始执行该任务
  
  可以看到，如果是 ForkJoinWorkerThread 运行过程中fork()，则直接加入到它的工作队列中，否则，重新提交任务。

• join() 和 invoke()： 主要作用是阻塞当前线程并等待获取结果
  
  通过 doJoin 或者 doInvoke 可以得到任务当前的状态有：

  • 已完成（NORMAL）：直接返回任务结果
  • 被取消（CANCELLED）：直接抛出CancllationException
  • 信号（SIGNAL）
  • 出现异常（EXCEPTIONAL）：直接抛出对应异常

• doJoin 和 doInvoke：

  private int doJoin() {
      Thread t; ForkJoinWorkerThread w; int s; boolean completed;
      //线程是ForkJoinWorkerThread
      if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread) {
          //任务执行完,直接返回
          if ((s = status) < 0)
          	return s;
          //没有执行完，取出任务执行
          if ((w = (ForkJoinWorkerThread)t).unpushTask(this)) {
              try {
                  //执行
              	completed = exec();
              } catch (Throwable rex) {
                  //记录异常信息，并设置状态为EXCEPTIONAL
             		return setExceptionalCompletion(rex);
              }
              //顺利执行完
              if (completed)
              	return setCompletion(NORMAL);
          }
          return w.joinTask(this);
      }else
        //等待
        return externalAwaitDone();
  }