ForkJoin并行任务框架

ForkJoin并行任务框架

一：概念

Fork/Join框架是Java 7提供的一个用于并行执行任务的框架， 核心思想就是把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果，其实现思想与MapReduce有异曲同工之妙。

二：工作窃取算法

Fork/Join框架使用一个巧妙的算法来平衡线程的负载，称为工作窃取（work-stealing）算法。

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

流程图如下：

三：ForkJoin框架使用

要使用ForkJoin框架，必须创建一个ForkJoin任务。即继承ForkJoinTask类；不过一般我们不直接继承ForkJoinTask类，而是继承其子类。

ForkJoinTask提供以下两个子类：

1：RecursiveAction

用于没有返回结果的任务；

2：RecursiveTask

用于有返回结果的任务；

四：代码实现

package com.test.thread;

import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.stream.LongStream;

/**
 * forkjoin
 */
public class ForkJoinTest {

    public static void main(String[] args) {
        //普通计算
        /*long start = System.currentTimeMillis();
        long sum = 0l;
        for(long i=0;i<=1_0000_0000;i++){
            sum=sum+i;
        }
        long end = System.currentTimeMillis();
        System.out.println("耗费时间："+(end-start)+"，计算结果："+sum);*/


        //通过ForkJoinJoin计算
        long start = System.currentTimeMillis();
        MyForkJoin myForkJoin = new MyForkJoin(0,1_0000_0000);
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        long res = forkJoinPool.invoke(myForkJoin);
        long end = System.currentTimeMillis();
        System.out.println("耗费时间："+(end-start)+"，计算结果："+res);

        //通过流计算
        /*long start = System.currentTimeMillis();
        long res = LongStream.rangeClosed(0,1_0000_0000).parallel().sum();
        long end = System.currentTimeMillis();
        System.out.println("耗费时间："+(end-start)+"，计算结果："+res);*/
    }
}

class MyForkJoin extends RecursiveTask<Long> {
    private long start;//起始值
    private long end;//结束值
    private static long temp=10000;//临界值，即递归任务中分割成小任务的条件

    //构造函数，用于实现递归
    public MyForkJoin(long start,long end){
        this.start = start;
        this.end = end;
    }
    public MyForkJoin(){
    }

    /**
     * 采用递归方式
     * @return
     */
    @Override
    protected Long compute() {
        long len = end - start;//每次递归判断起始值与结束值差
        //若是差大于临界值，继续拆分成小任务
        if(len > temp){//任务拆分，不做计算
            //获取中间值，从中间开始拆分成两个任务
            long middle = (start + end) / 2;
            MyForkJoin left = new MyForkJoin(start,middle);
            left.fork();//拆分子任务，压入线程队列（双端队列，用于工作窃取）
            MyForkJoin right = new MyForkJoin(middle+1,end);
            right.fork();//拆分子任务，压入线程队列（双端队列，用于工作窃取）
            long res1 = left.join();//等待子任务执行完毕
            long res2 = right.join();//等待子任务执行完毕
            long sum = res1 + res2;//返回计算结果
            return sum;
        }else {//不在拆分，开始计算，将计算结果返回到每个子任务，由上面的join方法接收结果
            //每个任务计算结果
            long sum = 0l;
            for(long i=start;i<=end;i++){
                sum = sum+i;
            }
            //返回计算结果
            return sum;
        }
    }
}

五：ForkJoinPool

执行ForkJoinTask；

long res = forkJoinPool.invoke(myForkJoin);