Fork/Join 框架

分而治之一直是一个有效地处理大任务的思想，当你不具备处理一个很大的任务时，可以将这个任务划分为多个小任务，

记录下这些小任务的结果，最后将这些小任务的结果合并成最终想要的结果。

一、在JDK中，fork/join框架主要干两件事情:

1.任务分割：首先Fork/Join框架需要把大的任务分割成足够小的子任务，如果子任务比较大的话还要对子任务进行继续分割

　　2.执行任务并合并结果：分割的子任务分别放到双端队列里，然后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果都放在另外一个队列里，启动一个线程从队列里取数据，然后合并这些数据。

二、下面介绍下Java中Fork/Join框架主要的两个类：

1. ForkJoinPool:ForkJoinTask需要通过ForkJoinPool来执行

　　任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。当一个工作线程的队列里暂时没有任务时，它会随机从其他工作线程的队列的尾部获取一个任务(工作窃取算法)。

2.ForkJoinTask:

我们要使用Fork/Join框架，首先需要创建一个ForkJoin任务。该类提供了在任务中执行fork和join的机制。通常情况下我们不需要直接集成ForkJoinTask类，只需要继承它的子类，Fork/Join框架提供了两个子类：

　　　　a.RecursiveAction：用于没有返回结果的任务

　　　　b.RecursiveTask:用于有返回结果的任务

三、实现原理

ForkJoinPool由ForkJoinTask数组和ForkJoinWorkerThread数组组成，ForkJoinTask数组负责将存放程序提交给ForkJoinPool，而ForkJoinWorkerThread负责执行这些任务。
　　ForkJoinTask的Fork方法的实现原理：
　　当我们调用ForkJoinTask的fork方法时，程序会把任务放在ForkJoinWorkerThread的pushTask的workQueue中，异步地执行这个任务，然后立即返回结果，

ForkJoinTask的join方法实现原理

　　Join方法的主要作用是阻塞当前线程并等待获取结果。让我们一起看看ForkJoinTask的join方法的实现，代码如下：

public final V join() {
        int s;
        if ((s = doJoin() & DONE_MASK) != NORMAL)
            reportException(s);
        return getRawResult();
    }

它首先调用doJoin方法，通过doJoin()方法得到当前任务的状态来判断返回什么结果，任务状态有4种：已完成（NORMAL）、被取消（CANCELLED）、信号（SIGNAL）和出现异常（EXCEPTIONAL）。

　　如果任务状态是已完成，则直接返回任务结果。

　　如果任务状态是被取消，则直接抛出CancellationException

　　如果任务状态是抛出异常，则直接抛出对应的异常

四、 Demo 展示

public class countTask extends RecursiveTask<Long>{
    private static final int THRRESHOLD = 10000;
    private long start;
    private long end;

    public countTask(long start, long end){
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        long sum = 0;
        boolean canCompute = (end-start)<THRRESHOLD;
        if(canCompute){
            for (long i = start; i <= end; i++) {
                sum +=i;
            }
        }else{
            //分成100个小任务
            long step = (start+end)/100;
            ArrayList<countTask> subTasks = new ArrayList<>();
            long pos = start;
            for (int i = 0; i < 100; i++) {
                long lastOne = pos+step;
                if(lastOne>end){
                    lastOne = end;
                }
                countTask subTask = new countTask(pos,lastOne);
                pos+=step+1;
                subTasks.add(subTask);
                subTask.fork();  //fork 提交子任务
            }
            for (countTask t:subTasks) {
                sum += t.join();
            }
        }
        return sum;
    }

    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        countTask task = new countTask(0,200000L);
        ForkJoinTask<Long> result = forkJoinPool.submit(task);
        try{
            long res = result.get();
            System.out.println("sum="+res);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

结果：

sum=20000100000

五、空闲线程的管理，如果一个工作线程取不到任务，可能挂起，挂起的线程被压入由线程池维护的栈中，待将来有任务可用时，再从栈中唤醒这些线程。

参考：

https://www.cnblogs.com/senlinyang/p/7885964.html

《Java高并发程序设计》

猜你喜欢