JUC并发编程——Fork/Jion框架

JUC并发编程——Fork/Jion框架

1、Fork/Jion 框架简介

Fork/Join 简介：就是在必要的情况下，将一个大任务，进行拆分 (fork) 成若干个小任务（拆到不可再拆时)，再将一个个的小任务运算的结果进行 join 汇总。
ForkJoin是由JDK1.7后提供多线并发处理框架，ForkJoin的框架的基本思想是分而治之。

Fork/Jion 特点：工作窃取

注：任务队列为双端队列，即可以使用先进先出的工作模式，也可以使用后进先出的工作模式。

2、Fork/Jion 的使用

使用ForkJoin框架或者说 ForkJoinPool，需要创建一个ForkJoin的任务( ForkJoinTask)。ForkJoinPool 为我们提供了 RecursiveAction 和 RecursiveTask 两个实现类。

两个实现类区别在于 RecursiveAction 任务没有返回值, RecursiveTask 任务可以带有返回值。

ForkJoin 使用实例：大量数据求和

package com.cheng.forkjoin;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.stream.LongStream;

public class ForkJoinDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //1、使用for普通方法计算
        long start1 = System.currentTimeMillis();
        Long sum1 = 0L;
        for (Long i = 1L; i <= 10_0000_0000; i++) {
            sum1 += i;
        }
        long end1 = System.currentTimeMillis();
        System.out.println("普通方法求和sum1="+sum1+"，时间-> "+(end1-start1));//普通方法求和sum1=500000000500000000，时间-> 7896


        //2、使用ForkJoin框架计算
        long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        SumTask task = new SumTask(1L, 10_0000_0000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);//向 ForkJoinPool 提交一个 ForkJoinTask 任务
        Long sum = submit.get();//得到执行结果
        long end = System.currentTimeMillis();
        System.out.println("ForkJoin框架求和sum="+sum+"，时间-> "+(end-start));//使用 Stream 并行流sum=500000000500000081，时间-> 168

        //3、使用 Stream 并行流计算
        long start2 = System.currentTimeMillis();
        long sum2 = LongStream.rangeClosed(0, 10_0000_0000)//生成0, 10_0000_0000之间的数
                .parallel()//切换成并行流，并行流就是把一个内容分成多个内数据块，并用不同的的线程分别处理每个数据块
                .reduce(1, Long::sum);
        long end2 = System.currentTimeMillis();
        System.out.println("使用 Stream 并行流sum="+sum2+"，时间-> "+(end2-start2));//sum=500000000500000000，时间-> 7406
    }

}
//计算任务类，继承RecursiveTask，带返回值
class SumTask extends RecursiveTask<Long> {

    private Long start; //子任务开始计算的值
    private Long end; //子任务结束计算的值
    static final Long TEMP = 10000L;//超过该阈值的任务数列就需要分解

    public SumTask(Long start, Long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        //如果条件成立，说明这个任务所需要计算的数值分为足够小了,可以正式进行累加计算了
        Long sum = 0L;
        if ((end - start) < TEMP){
            for (Long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
            // 否则再进行任务拆分，拆分成两个任务
        }else {
            Long middle = (start + end) / 2;
            SumTask task1 = new SumTask(start, middle);
            task1.fork();//将新创建的子任务放入当前线程的work queue队列
            SumTask task2 = new SumTask(middle +1, end);
            task2.fork();
            return task1.join() + task2.join();//join()会一直等待子任务执行完毕返回执行结果
        }
    }
}