Fork/Join框架 从入门到精通

在这篇文章中，将覆盖如下内容：

• 什么是Fork/Join框架
• 工作窃取算法
• Fork/Join框架的设计
• RecursiveAction 抽象类
• RecursiveAction 实战–同步方式
• RecursiveTask 抽象类
• RecursiveTask 实战– 同步方式
• RecursiveTask实战–异步方式
• Fork/Join框架的异常处理
• ForkJoinTask 抽象类
• ForkJoinPool
• 最佳实践

1.什么是Fork/Join 框架

Fork/Join 框架是java7提供的一个用于并行执行任务的框架，是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。

Fork Join 的运行流程图如下：

2.工作窃取

工作窃取（work-stealing)算法是指某个线程从其他队列里窃取任务来执行。

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

假如我们需要做一个比较大的任务，我们可以把这个任务分割为若干互不依赖的子任务，为了减少线程间的竞争，于是把这些子任务分别放到不同的队列里，并为每个队列创建一个单独的线程来执行队列里的任务，线程和队列一一对应，比如A线程负责处理A队列里的任务。

但是有的线程会先把自己队列里的任务干完，而其他线程对应的队列里还有任务等待处理。干完活的线程与其等着，不如去帮其他线程干活，于是它就去其他线程的队列里窃取一个任务来执行。而在这时它们会访问同一个队列，所以为了减少窃取任务线程和被窃取任务线程之间的竞争，通常会使用双端队列，被窃取任务线程永远从双端队列的头部拿任务执行，而窃取任务的线程永远从双端队列的尾部拿任务执行。

3.Fork/Join框架的设计

如何设计Fork/Join框架？
步骤1 分割任务。
步骤2 执行任务并合并结果。分割的子任务分别放在双端队列里，然后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果都统一放在一个队列里，启动一个线程从队列里拿数据，然后合并这些数据。

Fork/Join 使用两个类来完成以上两件事情。
① ForkJoinTask: 我们需要使用ForkJoin框架，必须首先创建一个ForkJoin任务。它提供在任务中执行fork()和join()操作的机制。通常情况下，我们不需要直接继承ForkJoinTask类，只需要继承它的子类，Fork/Join框架提供了以下两个子类。

• RecursiveAction: 用于没有返回结果的任务
• RecursiveTask: 用于有返回结果的任务

② ForkJoinPool: ForkJoinTask需要通过ForkJoinPool执行。

任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。当一个工作线程的队列里暂时没有任务时，它会随机从其他工作线程的队列的尾部获取一个任务。

4.RecursiveAction抽象类——没有返回值的任务

源码浅读

  public abstract class RecursiveAction extends ForkJoinTask<Void> {
    private static final long serialVersionUID = 5232453952276485070L;

  /**
   * 由这个任务执行的主要计算
   */
  protected abstract void compute();

  /**
   * 总是返回null
   */
  public final Void getRawResult() { return null; }

  /**
   * 搞不懂为什么要这么写？既然参数不用，为什么还要传入
   */
  protected final void setRawResult(Void mustBeNull) { }

  /**
   * 执行计算
   */
  protected final boolean exec() {
      compute();
      return true;
   }
}

继承自ForkJoinTask类。

compute()是抽象方法。

5. RecursiveAction实战–同步方式

目标：实现一个任务来修改产品列表的价格

步骤如下：

1.创建类Product，将用来存储产品的名称和价格。

public class Product {
  private String name;
  private double price;

  public String getName() {
      return name;
  }

  public void setName(String name) {
      this.name = name;
  }

  public double getPrice() {
      return price;
  }

  public void setPrice(double price) {
      this.price = price;
  }
}  

2.创建ProductListGenerator类，用来产生随机产品的数列

public class ProductListGenerator {
    public List<Product> generate(int size){
        List<Product> ret=new ArrayList<>();
        for(int i=0;i<size;i++){
            Product product = new Product();
            product.setName("Product"+i);
            product.setPrice(10);
            ret.add(product);
        }
        return ret;
    }
}

3.创建Task类，指定它继承RecursiveAction类。

public class Task extends RecursiveAction {
  private static final long serialVersionUID = 1L;

  private List<Product> products;

  private int first;
  private int last;

  private double increment;

  public Task(List<Product> products, int first, int last, double increment) {
      this.products = products;
      this.first = first;
      this.last = last;
      this.increment = increment;
  }

  @Override
  protected void compute() {
      if (last - first < 10) {
          updatePrices();
      } else {
          int middle = (last + first) / 2;
          System.out.printf("Task: Pending tasks: %s\n", getQueuedTaskCount());
          Task t1 = new Task(products, first, middle + 1, increment);
          Task t2 = new Task(products, middle + 1, last, increment);
        //它调用invokeAll()方法，执行每个任务所创建的子任务。这是一个同步调用，这个任务在继续（可能完成）它的执行之前，必须等待子任务的结束。
         // 当任务正在等待它的子任务（结束）时，正在执行它的工作线程执行其他正在等待的任务。
        // 在这种行为下，Fork/Join框架比Runnable和Callable对象本身提供一种更高效的任务管理。
          invokeAll(t1, t2);
      }
  }

  private void updatePrices() {
      for (int i = first; i < last; i++) {
          Product product = products.get(i);
          product.setPrice(product.getPrice() * (1 + increment));
      }
  }
}

4.通过创建Main类，并实现main()方法。

public class TaskMain {
  public static void main(String[] args) {
    ProductListGenerator generator = new ProductListGenerator();
    List<Product> products = generator.generate(100000);
    Task task = new Task(products, 0, products.size(), 0.2);
    System.out.println("task start");
//创建pool使用默认的无参构造函数，线程池使用的线程数由Runtime.getRuntime().availableProcessors()返回值决定
    ForkJoinPool pool = new ForkJoinPool();
    //在池中使用execute()方法执行这个任务。一个异步调用，而主线程继续它的执行。
    pool.execute(task);
    //显示每隔5毫秒池中的变化信息
    do {
        System.out.printf("Main: Thread Count: %d\n", pool.getActiveThreadCount());
        System.out.printf("Main: Thread Steal: %d\n", pool.getStealCount());
        System.out.printf("Main: Parallelism: %d\n", pool.getParallelism());
        System.out.println("------------------------");
        try {
            TimeUnit.MILLISECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    } while (!task.isDone());

    pool.shutdown();
    //使用isCompletedNormally()方法检查假设任务完成时没有出错，在这种情况下，写入一条信息到控制台。
    if (task.isCompletedNormally()) {
        System.out.printf("Main: The process has completed normally.\n");
    }

    for (int i = 0; i < products.size(); i++) {
        Product product = products.get(i);
        if (product.getPrice() != 12) {
            System.out.printf("Product %s: %f\n", product.getName(), product.getPrice());
          }
      }
      System.out.println("Main: End of the program.\n");
  }
}

6. RecursiveTask抽象类——有返回值的任务

public abstract class RecursiveTask<V> extends ForkJoinTask<V> {
    private static final long serialVersionUID = 5232453952276485270L;

    /**
     * 计算的结果