Fork/Join 框架框架使用

一、介绍

Fork/Join 框架是 Java7 提供了的一个用于并行执行任务的框架， 是一个把大任务分割成若干个小任务，最终汇总每一个小任务结果后获得大任务结果的框架。在多核计算机中正确使用能够很好的发挥cpu的做用，提升程序的执行效率。框架采用工做窃取算法，当有子任务线程处理完当前任务时，它会从其余线程执行的任务队列里窃取任务来执行，从而提升总体的执行效率。为了减小线程间的任务资源竞争，队列一般使用双端队列，别窃取任务线程永远从啥UN广大UN队列的呕吐不获取任务执行，而窃取任务的线程永远从双端队列的尾部获取任务执行。

二、使用

根据业务场景来考虑是否须要使用Fork/Join框架来进行任务的拆分和汇总操做。当须要时，好比说须要执行一个很大的业务计算之类的，此时使用Fork/Join框架分如下两步：

• 对任务进行分割        把大任务分割成子任务，有可能子任务仍是很大，因此还须要不停的分割，直到分割出的子任务足够小
• 执行分割的子任务并汇总结果       分割的子任务分别放在双端队列里，而后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果都统一放在一个队列里，启动一个线程从队列里拿数据，而后合并这些数据

具体实现以上两步：

1. 建立ForkJoinTask         它提供在任务中执行 fork() 和 join() 操做的机制，一般状况下咱们不须要直接继承 ForkJoinTask 类，而只须要继承它的子类,Fork/Join 框架提供了如下两个子类：   RecursiveAction：用于没有返回结果的任务   RecursiveTask ：用于有返回结果的任务
2. 使用ForkJoinPool执行ForkJoinTask       任务分割出的子任务会添加到当前工做线程所维护的双端队列中，进入队列的头部。当一个工做线程的队列里暂时没有任务时，它会随机从其余工做线程的队列的尾部获取一个任务

三、示例

3.1 使用fork

public class SumTask extends RecursiveTask <Integer>{
    private static final Integer THRESHOLD = 1000;
    private int start;
    private int end;
    public SumTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        Integer sum = 0;
        boolean isOk = (end - start) <= THRESHOLD;
        if(isOk) {
            for(int i = start; i <= end; i ++) {
                sum += i;
            }
            return sum;
        }

        int middle = (end + start) / 2;
        //子任务递归
        SumTask sumSubTask = new SumTask(start, middle);
        SumTask sumSubTask1 = new SumTask(middle + 1, end);

        //fork子任务
        sumSubTask.fork();
        sumSubTask1.fork();

        //join子任务
        Integer join = sumSubTask.join();
        Integer join1 = sumSubTask1.join();

        sum = join + join1;
        //计算结果
        return sum;
    }
}

3.2 使用invokeAll

public class SumTask2 extends RecursiveTask <Integer>{
    private static final Integer THRESHOLD = 1000;
    private int start;
    private int end;
    public SumTask2(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        Integer sum = 0;
        boolean isOk = end - start <= THRESHOLD;
        if(isOk) {
            for(int i = start; i <= end; i ++) {
                sum += i;
            }
//            System.out.println(String.format("compute %d-%d = %d", start, end, sum));
            return sum;
        }

        //除以2
        int middle = (end + start) / 2;
        //子任务递归
//        System.out.println(String.format("fork %d-%d => %d-%d&%d-%d", start, end, start, middle - 1, middle, end));
        SumTask2 sumSubTask = new SumTask2(start, middle - 1);
        SumTask2 sumSubTask1 = new SumTask2(middle, end);

        //fork子任务
        invokeAll(sumSubTask, sumSubTask1);

        //join子任务
        Integer join = sumSubTask.join();
        Integer join1 = sumSubTask1.join();

        sum = join + join1;
        //计算结果
        return sum;
    }
}

测试

　　　　 ForkJoinPool fjp2 = new ForkJoinPool();
        SumTask2 sumTask2 = new SumTask2(start, end);
        long begin3 = System.currentTimeMillis();
        Integer invoke = fjp2.invoke(sumTask2);
        long end3 = System.currentTimeMillis();
        System.out.println("计算结果3为 sum = " + invoke + ",计算时长为" + begin3 + "-" + end3 + "---  " + (end3 - begin3) + "ms");

        ForkJoinPool fjp = new ForkJoinPool();
        long begin2 = System.currentTimeMillis();
        SumTask sumTask = new SumTask(start, end);
        ForkJoinTask<Integer> submit = fjp.submit(sumTask);
        Integer join = submit.join();
        long end2 = System.currentTimeMillis();
        System.out.println("计算结果2为 sum = " + join + ",计算时长为" + begin2 + "-" + end2 + "---   " + (end2 - begin2) + "ms");
    

结果

从结果（能够屡次运行测试）能够看出，使用invokeAll方式效率比使用单独fork方式高，因此在使用时尽可能采用invokeAll方式，这样能够充分利用线程池中的线程去执行任务。

 

源码参照Github