ForkJoin高并行线程框架

ForkJoin(分叉加入):高并行线程框架

• 一种高效的解决多并发问题的框架

• 釆用"分而治之"的思想:任务量足够大时,将总任务拆分成多个子任务

• 多线程执行子任务,子任务完成返回结果值

• 结果值合并后向上递归,直到最后得到总值

---

一般常用的是继承RecursiveTask类,有返回值

计算高斯算法

package com.li.changGe.multithreading.forkJoin;

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

public class RecursiveTaskDemo01 extends RecursiveTask<Integer> {

  /**
   * 传参时将线程总量传进来
   *
   * 不到达阈值就一直拆分任务
   */
  public static final int threshold = 2;
  private int start;
  private int end;


  public RecursiveTaskDemo01(int start, int end) {
    this.start = start;
    this.end = end;
  }


  /**
   * 计算高斯算法1~100
   *
   * 如果计算最大项 - 最小项 小于或等于 阈值
   * 表明计算量小,直接常规计算
   *
   * 不然的会就将总计算量分为两个子任务,分开计算
   *
   * 子任务计算后会返回一个结果
   * 将所有子任务的结果相加,得到最终总值
   */

  /**
   * RecursiveTask:实现他的compute()方法可以得到返回值
   */
  @Override
  protected Integer compute() {
    int sum = 0;
    /**
     * 如果任务足够小就直接计算任务
     *
     * 不然就拆分成两个子任务不停递归
     * 直到符合阈值再回去计算
     */
    boolean canCompute = (end - start) <= threshold;
    if (canCompute) {
      //直接计算
      for (int i = start; i <= end; i++) {
        sum += i;
      }
    } else {
      //大于阈值,分裂成两个子任务计算
      int middle = (start + end) / 2;
      RecursiveTaskDemo01 leftTask = new RecursiveTaskDemo01(start, middle);
      RecursiveTaskDemo01 rightTask = new RecursiveTaskDemo01(middle + 1, end);
      System.out.println("中间值为"+middle+",left开始:"+leftTask.start+",left结束:"+leftTask.end
      +",right开始:"+rightTask.start+",right结束:"+rightTask.end);

      /**
       * 将这两个子任务加入线程池
       *
       * 执行完毕返回结果
       */
      leftTask.fork();
      rightTask.fork();
      // 等待任务执行结束合并其结果
      int leftResult = leftTask.join();
      int rightResult = rightTask.join();
      System.out.println(leftResult+"-"+rightResult);
      // 合并子任务结果
      sum = leftResult + rightResult;
    }
    return sum;
  }

  public static void main(String[] args) {
    /**
     * 将需要ForkJoin的任务加入ForkJoin线程池
     *
     * 他会返回你一个返回值对象,里面有最终结果
     */
    ForkJoinPool forkjoinPool = new ForkJoinPool();
    //生成一个计算任务，计算1+2+3+4
    RecursiveTaskDemo01 task = new RecursiveTaskDemo01(1, 100);
    //执行一个任务
    Future<Integer> result = forkjoinPool.submit(task);

    try {
      System.out.println("result:"+result.get());
    } catch (Exception e) {
      System.out.println("exception"+e);
    }

  }//main



}

---

1. 如图:left任务得到的值为3,是由子任务1+2得到.right任务7由子任务3+4得到

2. 两个任务相加得到10,成为他们的父级任务的left任务.而父级任务的right任务由5+6+7得来

3. 父级任务相加得到28,返回给他的父级的left任务…
   

---

RecursiveAction没有返回值:适合于"有去无回"的任务

package com.li.changGe.multithreading.forkJoin;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveAction;

public class RecursiveActionDemo01 extends RecursiveAction {
  private int start;

  public RecursiveActionDemo01(int start, int end) {
    this.start = start;
    this.end = end;
  }

  private int end;


  public static void main(String[] args) {
    /**
     * 将任务加入线程池
     * 返回一个执行对象
     *
     * 这个对象中包含了执行的信息
     */
    ForkJoinPool forkJoinPool = new ForkJoinPool();

    RecursiveActionDemo01 recursiveActionDemo01 = new RecursiveActionDemo01(0, 100);

    ForkJoinTask<Void> submit = forkJoinPool.submit(recursiveActionDemo01);

    try {
      Void unused = submit.get();
      System.out.println(unused);
    } catch (InterruptedException e) {
      e.printStackTrace();
    } catch (ExecutionException e) {
      e.printStackTrace();
    }

  }

  /**
   * 总共100只鸡,不停分发给所有工人处理
   */
  @Override
  protected void compute() {
    int threshold = 2;

    if((end - start) > 0){

      boolean isFork = (end - start) <= threshold;

      if(isFork){
        System.out.println("一个工人直接处理了所有的"+(end - start)+"只鸡");
      }else {
        int middle = (end - start) /2;
        RecursiveActionDemo01 leftFork = new RecursiveActionDemo01(start, middle);
        RecursiveActionDemo01 rightFork = new RecursiveActionDemo01(middle+1,end);


        leftFork.fork();
        rightFork.fork();

        leftFork.join();
        rightFork.join();

        System.out.println("left处理了从"+leftFork.start+"到"+leftFork.end);
        System.out.println("right处理了从"+rightFork.start+"到"+rightFork.end);
      }

    }

  }


}