浅析Java的Frok/Join框架 一丶Fork/Join框架产生背景：二丶工作窃取算法三丶Fork/Join框架的设计思想四丶JDK实现Fork/Join框架五丶ForkJoin框架的实现原理

if(任务足够小){
    进行计算；
}else{
    将任务分为两个部分；
    结合两个子任务；
}

//继承RecursiveTask，用于与结果返回的任务
public class CountTask  extends RecursiveTask<Integer>{
    //阈值为2，当小于等于这个值的时候进行计算
    private static final int THRESHOLD = 2;
    
    //累加的起始值
    private int start;
    private int end;
    
    public CountTask(int start,int end){
        this.start = start;
        this.end = end;
    }
    
    protected Integer compute() {
        int sum = 0;
        boolean canCompute = (end-start) <= THRESHOLD;
        //如果false，表示end-start大于2，还要进行分割
        if(canCompute) {
            for(int i = start;i<=end; i++ ) {
                sum += i;
            }
        }
        else {
            int mid = (end + start) / 2;
            //分为两个任务
            CountTask leftTask = new CountTask(start,mid);
            CountTask rightTask = new CountTask(mid + 1,end);
            //执行子任务
            leftTask.fork();
            rightTask.fork();
            //等待子任务完成
            int leftResult = leftTask.join();
            int rightResult = rightTask.join();
            //合并子任务
            sum = leftResult+rightResult;
            
        }
        return sum;
    }
    
    public static void main(String[] args) {
        //创建ForkJoinPool 对象执行任务
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        //计算1-5累加
        CountTask task = new CountTask(1,5);
        //执行
        Future<Integer> result = forkJoinPool.submit(task);
        try {
            System.out.println(result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

public <T> ForkJoinTask<T> submit(ForkJoinTask<T> task) {
        //任务为空抛异常
        if (task == null)
            throw new NullPointerException();
        //调用externalPush方法，这个我们往下看，看看它玩啥花样
        externalPush(task);
        return task;
    }

  final void externalPush(ForkJoinTask<?> task) {
        //工作队列，也就是之前介绍框架时所提到的偷窃队列
        //创建队列数组的个数和线程数一致
        WorkQueue[] ws; WorkQueue q; int m;
        //getProbe用来为当前线程生成一个不强制初始化的取样值
        int r = ThreadLocalRandom.getProbe();
        //runState为ForkJoinPool 的volatile字段，表示锁的状态
        int rs = runState;
        //workQueues为ForkJoinPool 的数组volatile类型字段
        //当这个队列不为空（如果为空肯定是要初始化一个队列的）
        //并且队列长度大于等于0
        //额...后面原谅我看不懂了
        //但是大概的意思应该是要调用我们自定义的task对象的方法，对这个任务进行分割
        if ((ws = workQueues) != null && (m = (ws.length - 1)) >= 0 &&
            (q = ws[m & r & SQMASK]) != null && r != 0 && rs > 0 &&
            U.compareAndSwapInt(q, QLOCK, 0, 1)) {
            ForkJoinTask<?>[] a; int am, n, s;
            if ((a = q.array) != null &&
                (am = a.length - 1) > (n = (s = q.top) - q.base)) {
                int j = ((am & s) << ASHIFT) + ABASE;
                //将task放入ForkJoinTask数组中
                U.putOrderedObject(a, j, task);
                U.putOrderedInt(q, QTOP, s + 1);
                U.putIntVolatile(q, QLOCK, 0);
                //signalWork是用来创建线程来执行任务
                if (n <= 1)
                    signalWork(ws, q);
                return;
            }
            U.compareAndSwapInt(q, QLOCK, 1, 0);
        }
        externalSubmit(task);
    }

 public final ForkJoinTask<V> fork() {
        Thread t;
        if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread)
            ((ForkJoinWorkerThread)t).workQueue.push(this);
        else
            ForkJoinPool.common.externalPush(this);
        return this;
    }

  final void push(ForkJoinTask<?> task) {
            ForkJoinTask<?>[] a; ForkJoinPool p;
            int b = base, s = top, n;
            if ((a = array) != null) {    // ignore if queue removed
                int m = a.length - 1;     // fenced write for task visibility
                U.putOrderedObject(a, ((m & s) << ASHIFT) + ABASE, task);
                U.putOrderedInt(this, QTOP, s + 1);
                if ((n = s - b) <= 1) {
                    if ((p = pool) != null)
                        p.signalWork(p.workQueues, this);
                }
                else if (n >= m)
                    growArray();
            }
        }