Java Fork/Join框架学习（一）

1. 序言：分治算法

• ForkJoinTask使用了的分治算法的思想，因此在学习ForkJoinTask前，回顾下分治算法
• 实际问题：国家开展人口普查，如何统计人口数？
• 负责该事项的工作人员，肯定不会傻傻地带上电脑，一个人走遍全中国
• 而是将该事项下发到省，省下发到市，市下发到县，县下发到镇，镇下发到乡（divide，分）
• 假设乡足够小，工作人员能够轻松完成乡上人口的统计，这时候便可以不再下发任务，直接统计乡人口
• 然后镇汇总乡、县汇总镇、市汇总县、省汇总市，中央汇总省，从而完成此次人口普查（combine，合）
• 分治算法包含三大步：
  • Divide：将问题划分为两个或两个以上与原始问题相似但规模较小的子问题。
  • Conquer：如果子问题足够小，则直接求解；否则，递归求解子问题。
  • Combine: 合并子问题的解决方案，以构建原始问题的解
• 如何理解递归求解子问题？
  • 在笔者看来，divide：需要将问题分解为足够小的子问题，但是很难一次就完成。因此，需要递归地对子问题进行分解，直到能直接求解
  • 这样来看，divide和conquer是无法严格界定的，因为在conquer时，如果发现子问题不能直接求解，还需要递归地进行divide & conquer
• 下面的代码很好地解释了分治算法的整个流程：

  divideAndConquer(big_problem){
    if (canSolve(big_problem)){ //问题可以直接求解则直接求解返回
        solve(big_problem); //求解
        return; 
    } else {
        small_problem_A = divide(big_problem); //不能直接求解的问题拆分
        small_problem_B = divide(big_problem); //不能直接求解的问题拆分
        divideAndConquer(small_problem_A); //递归求解子问题
        divideAndConquer(small_problem_B); //递归求解子问题
        return merge(); //合并子问题的解
    }
  }
  

2. Fork/Join框架

2.1 Fork/Join框架概述

• JDK 7开始，引入了Fork/Join框架

• 该框架采用了分治算法的思想，将大任务拆分为若干个独立的小任务，最后合并每个小任务的执行结果以得到大任务的执行结果

• 这样可以充分利用操作系统的多核特性，加速对小任务的并行处理，从而提高大任务的吞吐量

• 可以说，Java的Fork/Join框架，提供了一种充分利用所有可用的处理能力来加速并行处理的工具
  

• 伪代码解释如下：

  // from 《A Java Fork/Join Framework》Dong Lea
  Result solve(Problem problem) {
  	if (problem is small)
   		directly solve problem
   	else {
   		split problem into independent parts
   		fork new subtasks to solve each part
   		join all subtasks
   		compose result from subresults
  	}
  }
  

• 注意： ForkJoinTask的类注释中，明确提到：一个非常粗略的经验法则，一个任务的基本计算步骤应该 > 100 且 < 10000，同时需要避免无循环

  • 因为如果任务过大，无法充分利用处理器的多核特性，导致任务吞吐量较低
  • 如果任务太小，并发执行时的上下文切换、内存开销等会使得操作系统高负载，反而不利于任务的执行

2.2 fork & join

fork

• fork/join框架先将任务递归分解为较小的独立子任务，直到这些子任务足够简单以异步执行。
• 英文单词fork的动词释义为分岔，结合上图（类似树状图）对任务拆分过程的描述，就像将较大的任务分岔出多个子任务一样
• 所以，这里的拆分操作就叫做fork

join

• 完成任务拆分后，等子任务执行完成，需要将所有子任务的结果递归汇总成一个结果（也就是大任务的执行结果）
• 在SQL领域，join用于将多张表的结果关联起来
• 在fork/join框架中，将子任务的结果汇总起来，就是一种join操作

2.3 重要成员

2.3.1 ForkJoinPool

• Fork/Join框架的专用线程池，一种用于运行ForkJoinTask的ExecutorService
• ForkJoinPool只接受ForkJoinTask类型的任务，虽然Runnable或Callable任务也能正常提交，但是会被ForkJoinPool自动转化为ForkJoinTask
• 实现了工作窃取（work-stealing）算法，最大程度利用线程池中的线程，避免这些线程累的累死、闲的闲死，从而提高任务的处理效率
• work-stealing：空闲的工作线程从其他处于busy状态的工作线程处窃取等待执行的任务，准确地说：从处于busy状态的工作线程关联的WorkQueue中窃取等待执行的任务

2.3.2 ForkJoinTask

• Fork/Join框架中任务的抽象基类，它有三个常用的抽象子类：
  • 有返回值的RecursiveTask
  • 无返回值的RecursiveAction
  • 带钩子函数的CountedCompleter，在任务完成后会触发钩子函数；这里的完成，可能是正常执行完毕，也可能是异常退出
• 使用时，一般会继承上述三个子类来实现业务需求，而不会直接继承 ForkJoinTask 类
• 在ForkJoinPool中，ForkJoinTask分为两类：
  • 外部提交的submission task，即非ForkJoin线程（non-FJ threads）通过ForkJoinPool的invoke()、execute()、submit()方法提交的任务
  • ForkJoinTask执行过程中，通过fork操作分割出的子任务，worker task

2.3.3 WorkQueue

• 同其他线程池一样，ForkJoinPool也使用队列对提交到池中的任务进行管理

• WorkQueue是一个双端队列，支持任务提交和work-stealing

• 它包含top和base两个指针，正常的任务提交和获取在top处进行，work-stealing在base处进行

  • 任务都是从队列的top处插入，简称push操作

    q.array[q.top] = task; ++q.top;
    

  • 工作线程从自身关联队列的top处获取task，简称pop操作 —— LIFO序

    if ((base != top) and
    	(the task at top slot is not null) and
       (CAS slot to null))
           decrement top and return task;
    

  • 工作线程从其他队列的base处窃取task，简称poll操作 —— FIFO序

    if ((base != top) and
         (the task at base slot is not null) and
         (base has not changed) and
         (CAS slot to null))
             increment base and return task;
    

• ForkJoinPool中，有一个WorkQueue[]数组，名叫workQueues：

  • 下标为偶数（even）的WorkQueue用于存储submission task，叫做submission queue或shared queue
  • 下标为奇数（odd）的WorkQueue用于存储worker task，叫做worker queue或un-shared queue

• 为什么submission queue又叫shared queue？ —— 介绍完ForkJoinWorkerThread就能回答该问题

2.3.4 ForkJoinWorkerThread

• ForkJoinPool中执行ForkJoinTask的工作线程，又叫worker
• ForkJoinWorkerThread没有公开的构造函数，只能通过实现ForkJoinPool.ForkJoinWorkerThreadFactory接口中的newThread()方法进行创建

  public ForkJoinWorkerThread newThread(ForkJoinPool pool);
  

• ForkJoinPool也提供了ForkJoinWorkerThreadFactory接口的默认实现：DefaultForkJoinWorkerThreadFactory
• ForkJoinPool只为worker queue分配ForkJoinWorkerThread，而submission queue没有对应的ForkJoinWorkerThread

work-stealing的重要性

• 由于submission queue未关联worker，外部提交的submission task进入submission queue后，如果不借助work-stealing则永远无法执行
• work-stealing使得worker queue关联的空闲worker会从submission queue窃取任务并执行，从而保证了submission task的正常执行

为什么submission queue又叫shared queue？

• submission queue中的任务，必须借助worker queue关联的worker + work stealing才能被执行
• 它就像一个共享的queue一样，任何worker都可以从其中窃取任务并执行
• submission queue的开放性 + work stealing，弥补了submission queue没有worker的短处

2.3.5 小结

• 如果不考虑具体细节，Fork/Join框架的四个重要成员的关系如下图所示
  

3. 编程实战，体验Fork/Join框架

• 基于ForkJoinTask的抽象子类RecursiveTask和RecursiveAction进行编程实战，以体验Fork/Join框架

3.1 数组排序

• 对于有成千上万个元素的数组进行排序，可以考虑使用Fork/Join框架，将其划分成合适大小的子数组后，直接使用Arrays.sort()进行排序

• 排序过程中，直接对数组进行操作，无需任何返回值。因此，可以继承RecursiveAction实现对应的ForkJoinTask

• 排序任务的实现

  public class SortArrayTask extends RecursiveAction {
      private static final int THRESHOLD = 1000;
      private final int[] array;
      private final int low;
      private final int high;
  
      public SortArrayTask(int[] array) {
          this(array, 0, array.length - 1);
      }
  
      SortArrayTask(int[] array, int low, int high) {
          this.array = array;
          this.low = low;
          this.high = high;
      }
  
      /**
       * 自定义compute方法，在其中实现排序任务的分治逻辑：
       * <p>1. 定义最小执行单元：满足条件，可以不用继续拆分（fork），直接进行计算</p>
       * <p>2. 定义任务的拆分逻辑：不满足条件时，如何拆分任务</p>
       * <p>3. 定义合并逻辑（如果需要的话）：合并子任务的执行合并</p>
       */
      @Override
      protected void compute() {
          // 满足最小执行单元，直接进行排序
          if (high - low < THRESHOLD) {
              sortArray(array, low, high + 1);
          } else {
              // 拆分数组，分别进行排序
              int mid = (high + low) / 2;
              SortArrayTask leftTask = new SortArrayTask(array, low, mid);
              SortArrayTask rightTask = new SortArrayTask(array, mid + 1, high);
              invokeAll(leftTask, rightTask);
              // 合并排序结果,参考RecursiveAction类的注释，实现的一种减少空间和时间复杂度的、巧妙的合并方法
              mergeArray(array, low, mid, high);
          }
      }
  
      public void mergeArray(int[] array, int low, int mid, int high) {
          // 先将左半部分复制到临时数组
          int[] temp = Arrays.copyOfRange(array, low, mid + 1);
          // 将临时数组与右半部分比较，实现数组合并
          for (int k = 0, right = mid + 1, j = low; k < temp.length; k++) {
              // 合并temp[k]的情况：① 右半部分没有了元素；② 右半部分有元素，但数值较大
              array[j++] = (right > high || temp[k] < array[right]) ? temp[k++] : array[right++];
          }
      }
  
      public void mergeArray(int[] array, int low1, int high1, int low2, int hig2) {
          int[] temp = new int[hig2 - low1 + 1];
          int k = 0;
          int left1 = low1;
          int left2 = low2;
          while (left1 <= high1 && left2 <= hig2) {
              temp[k++] = array[left1] < array[left2] ? array[left1++] : array[left2++];
          }
          // 合并剩余元素
          while (left1 <= high1) {
              temp[k++] = array[left1++];
          }
          while (left2 <= hig2) {
              temp[k++] = array[left2++];
          }
          // 将临时数组复制到当前数组
          k = 0;
          while (low1 <= hig2) {
              array[low1++] = temp[k++];
          }
      }
      
      public void sortArray(int[] arr, int start, int end) {
          System.out.printf("%s -- 数组排序，start：%d, end: %d\n", Thread.currentThread().getName(), start, end);
          Arrays.sort(arr, start, end); // Arrays.sort()不包含end元素
      }
  }
  

• 使用ForkJoinPool提交排序任务，排序完成后，为了观察排序效果打印首尾10个元素

  public class SortArrayTaskTest {
      public static void main(String[] args) {
          // 初始化待排序数组数组
          int[] array = SortArrayTaskTest.generateIntArray(5000);
  
          // 通过ForkJoinPool提交并执行ForkJoinTask
          // 使用ForkJoinPool提供的common线程池，未自定义ForkJoinPool
          ForkJoinPool forkJoinPool = ForkJoinPool.commonPool(); 
          // 直接执行任务，invoke()方法会在任务执行结束后返回结果
          forkJoinPool.invoke(new SortArrayTask(array));
          // 打印数组的首尾元素
          System.out.println("排序后，数组前10个元素");
          for (int i = 0; i < 10; i++) {
              System.out.printf(array[i] + " ");
          }
          System.out.println("\n排序后，数组后10个元素");
          for (int i = array.length - 11; i < array.length; i++) {
              System.out.printf(array[i] + " ");
          }
      }
  
      public static int[] generateIntArray(int length) {
          int[] array = new int[length];
          for (int i = 0; i < length; i++) {
              array[i] = Integer.parseInt(RandomStringUtils.random(4, false, true));
          }
          return array;
      }
  }
  

• 执行结果如下，通过执行结果可知：以1000为阈值，将原始数组划分为多个大小不超过1000的子数组，排序、合并后得到一个全局有序的数组
  

3.2 统计数组中超过阈值的元素个数

• 统计数组中超过阈值的元素个数，如果数组过大，同样可以考虑使用Fork/Join框架：将其划分成合适大小的子数组后，直接遍历、统计

• 每个统计任务，需要返回当前子数组中超过阈值的元素个数。因此，因此需要继承RecursiveTask<Integer>实现对应的ForkJoinTask

• 基于Fork/Join框架的统计任务实现如下：

  public class CountElementTask extends RecursiveTask<Integer> {
      private static final int SIZE_THRESHOLD = 1000;
      private final int[] array;
      private final int threshold;
      private final int start;
      private final int end;
  
      public CountElementTask(int[] array, int threshold) {
          this(array, 0, array.length, threshold);
      }
  
      CountElementTask(int[] array, int start, int end, int threshold) {
          this.array = array;
          this.start = start;
          this.end = end;
          this.threshold = threshold;
      }
  
      @Override
      protected Integer compute() {
          //  最小执行单元，直接遍历数组，统计超过阈值的元素个数
          if (end - start <= SIZE_THRESHOLD) {
              // 打印相关信息
              System.out.printf("%s -- 遍历数组，start: %d, end: %d\n", Thread.currentThread().getName(), start, end);
              int count = 0;
              for (int i = start; i < end; i++) {
                  if (array[i] > threshold) {
                      count++;
                  }
              }
              return count;
          }
  
          // 拆分子任务，递归求解
          int mid = (end + start) >>> 1;
          CountElementTask task1 = new CountElementTask(array, start, mid, threshold);
          CountElementTask task2 = new CountElementTask(array, mid, end, threshold);
          // fork()会将任务插入ForkJoinPool的队列，是递归求解的关键
          // System.out.printf("%s -- 向队列提交子任务，task1: start = %d, end = %d, task2: start = %d; end2 = %d\n",Thread.currentThread().getName(), start, mid, mid, end);
          task1.fork();
          task2.fork();
          // 合并子任务结果：worker从当前队列获取任务并执行，需要按照innermost-first原则
          return task2.join() + task1.join();
      }
  }
  

• 使用统计任务，对有3000个元素的数组进行统计，统计其超过阈值5000的元素个数

  public class CountElementTaskTest {
      private static final int THRESHOLD = 5000;
      private static final int ARRAY_SIZE = 3000;
  
      public static void main(String[] args) throws ExecutionException, InterruptedException {
          // 初始化待排序数组数组
          int[] array = SortArrayTaskTest.generateIntArray(ARRAY_SIZE);
  
          // 通过ForkJoinPool提交并执行ForkJoinTask
          ForkJoinPool forkJoinPool = ForkJoinPool.commonPool();
          ForkJoinTask<Integer> result = forkJoinPool.submit(new CountElementTask(array, THRESHOLD));
          // 获取任务执行结果
          System.out.printf("数组中，共%d个元素超过阈值%d\n", result.get(), THRESHOLD);
          // 直接遍历，比较统计结果
          int count = 0;
          for (int i = 0; i < array.length; i++) {
              if (array[i] > THRESHOLD) {
                  count++;
              }
          }
          System.out.printf("直接遍历的统计结果：共%d个元素超过阈值%d", count, THRESHOLD);
      }
  }
  
  

• 执行结果如下：
  

3.3 一些疑问

• 从上面的编程实战可知，任务的执行逻辑都定义在了重写的compute()方法中。
• 只是简单地向ForkJoinPool提交了一个原始任务，后续就自动按照compute()方法的逻辑对任务进行递归求解
• 疑问一： 向ForkJoinPool提交任务后，最终是如何执行到compute()方法的？

---

• 实现数组排序时，拆分出的SortArrayTask子任务并未调用其fork()和join()方法，而是直接使用用invokeAll()
• 而实现数组中超过阈值的元素统计时，却使用fork()、join()方法处理CountElementTask子任务
• 疑问二：在Fork/Join框架中，任务的拆分、执行与合并可以使用哪些方法？这些方法有何区别？

---

• 向ForkJoinPool提交任务时，示例1使用的是invoke()方法，示例2使用的submit()方法
• 疑问三：Client（或submiter）可以通过哪些方法向ForkJoinPool提交任务？这些方法有何区别？

---

• 前面对Fork/Join框架的四个重要成员的简单介绍，小结如下：
  • Fork/Join框架中，ForkJoinPool使用WorkQueue（队列）对ForkJoinTask进行管理
  • 下标为偶数 or 奇数的队列，其职责有所差异：
    • 下标为偶数的队列
      • 叫做submission queue或share queue，只负责存储外部submiter提交的任务；
      • 同时，由于没有对应的worker与之关联，借助work- stealing机制，submission queue中的任务才得以执行
    • 下标为奇数的队列：
      • 叫做worker queue，关联一个worker，最初的任务是借助worke-stealing机制从submission queue窃取的
      • 在处理任务的过程中，worker会fork出的新任务将提交到当前队列
      • 当前队列有任务后，worker会从当前队列的top处获取任务
      • worker在当前队列的push和pop操作，因为单线程而不用考虑并发
• 疑问四：submiter提交的任务，是如何push到submission queue的？
• 疑问五：submission queue没有worker与之关联，而worker queue却有，这两种的队列的创建有何区别？
• 疑问六：work-stealing是如何实现的？

---

• 疑问…
• 用笔者和同事之间交流的一句话说：很多东西看似简单，只要你肯深入学习，没有个几天你是搞不定的
• 后续的内容，我们将带着上面的这些疑惑，去深入学习Fork/Join框架

---

• Fork/Join框架的相关内容太多，拆分成多篇博客
  • 下一篇博客： Java Fork/Join框架学习（二）