【Java线程篇】分而治之：Fork/join框架

介绍：
这是一种很有效地处理大量数据的方法，著名的MapReduce也是采用这种分而治之的思想。fork()函数用来创建子进程，是的系统进程对一个执行分支。
但是，值得注意的是，如果毫无顾忌地使用fork()开启线程进行处理，那么很可能导致系统开启过多的线程而严重影响性能。因此，在JDK中给出了ForkJoinPool线程池，对于fork()方法并不急于开启线程，而是提交给ForkJoinPool线程池进行处理，以节省系统的资源。
实际的场景中，可能会出现，线程A已经收工了，但是B还有一大堆的任务，此时A会帮助B，从B队列中取一个任务来处理，尽可能达到平衡。互相帮助的精神。注意，当线程视图帮助别人时，总是从任务底部开始拿数据，二线程执行自己任务时，则是从相反的顶部开始拿。这种行为十分有利于避免数据竞争。主要的流程如下图：

使用说明：
ForkJoinPool: ForkJoin同样是利用了线程池，和ThreadPoolExecutor一样实现了自己的线程池。对任务进行调度

ForkJoinTask: 在Fork/Join框架中执行的任务类。子任务对其进行继承
RecursiveAction: 用于不用返回结果的子任务
RecursiveTask: 用于返回有结果的子任务

ForkJoin工作窃取（work-stealing）算法简介：
使得若一个工作线程的task队列为空，没有任务可以执行时，从其他工作线程中获取任务主动执行。为了实现工作窃取，在工作线程中维护双端队列，窃取任务线程从队尾取任务，被窃取任务线程从队头获取任务。这种机制充分利用线程进行并行计算，减少线程竞争。但是当队列中只存在一个任务了时，两个线程去取反而会造成资源浪费。
Demo示例：

/**
 * Fork/Join分而治之的使用
 * @author T.c
 * 创建时间：2016年11月10日 上午7:10:30
 *
 */
public class CountTask extends RecursiveTask<Long>{
    private static final int THRESHOLD = 10000;
    private long start;
    private long end;
    public CountTask(long start, long end) {
        this.start = start;
        this.end = end;
    }

    public Long compute(){
        long sum = 0;
        boolean canCompute = (end - start)<THRESHOLD;
        if(canCompute){
            for(long i=start;i<=end;i++){
                sum +=i;
            }
        }else{
            // 分成100个小任务执行
            long step = (start+end)/100;
            ArrayList<CountTask> subTasks = new ArrayList<CountTask>();
            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(); // 将子任务推向线程池
                    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); //tip1: 将任务丢到线程池
        try {
            Long res = result.get(); 
            System.out.println("sum="+res);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

分析：因为计算数列的和必然需要有返回值，因此选用RecursiveTask作为任务的模型。在tip1处将任务提交给线程池，线程池将返回一个携带结果的任务，通过get()方法可以得到最终的结果。如果在执行get()方法时，任务没有结束，那么主线程就会在get()方法时等待。
此外代码第一行THRESHOLD设置了任务分解的规模。任务总和大于这个数，任务被再次分解，否则直接执行。若一次分解不通过则在此分解。每次分解都是将任务分成100个等规模的小任务，并使用fork提交子任务。之后，等待所有的子任务结束，并将结果在此求和。

注意事项：如果分解的层次很深，一直得不到返回，可能2种原因：1.系统内的线程数量越积越多，导致性能严重下降。2.太深，最终导致栈溢出。