14.ForkJoinPool 分支-合并框架 工作窃取

import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

/**
 * @author Aron.li
 * @date 2020/11/4 22:07
 */
public class TestForkJoinPool {

    public static void main(String[] args) {
        //1.获取当前的时间
        Instant start = Instant.now();
        //2.创建ForkJoinPool线程池
        ForkJoinPool pool = new ForkJoinPool();
        //3.创建一个计算框架任务
        ForkJoinTask<Long> task = new ForkJoinSumCalculate(0L, 50000000000L);
        //4.执行线程，获取结果
        Long sum = pool.invoke(task);
        System.out.println(sum); // -4378596987249509888
        //5.获取结束的时间
        Instant end = Instant.now();
        //6.计算耗时
        System.out.println("耗费时间为：" + Duration.between(start, end).toMillis()); // 耗费时间为：4595
    }

}


//模拟Fork/Join 框架
class ForkJoinSumCalculate extends RecursiveTask<Long> {

    //继承RecursiveTask需要带有一个序列号做标识
    private static final long serialVersionUID = -259195479995561737L;

    //拆分的起点和终点
    private long start;
    private long end;

    //拆分的临界值
    private static final long THURSHOLD = 10000L;

    //构造器
    public ForkJoinSumCalculate(long start, long end) {
        this.start = start;
        this.end = end;
    }

    //计算拆分方法
    @Override
    protected Long compute() {
        //计算当前拆分的长度
        long length = end - start;

        //如果拆分的长度小于临界值
        if (length <= THURSHOLD) {
            long sum = 0L;
            for (long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        } else { // 如果拆分的长度大于临界值，则继续拆分

            long middle = (start + end) / 2;

            ForkJoinSumCalculate left = new ForkJoinSumCalculate(start, middle);
            left.fork(); //进行拆分，同时压入线程队列

            ForkJoinSumCalculate right = new ForkJoinSumCalculate(middle + 1, end);
            right.fork(); //进行拆分，压入线程队列

            return left.join() + right.join(); // 最后返回合并的线程
        }
    }

}