class Fibonacci extends RecursiveTask<Integer> {
   final int n;
   Fibonacci(int n) { this.n = n; }
   Integer compute() {
     if (n <= 1)
       return n;
     Fibonacci f1 = new Fibonacci(n - 1);
     f1.fork();
     Fibonacci f2 = new Fibonacci(n - 2);
     return f2.compute() + f1.join();
   }
 }

// Node 1 : 返回結(jié)果 , 存放最終結(jié)果
V result;
​
// Node 2 : 抽象方法 compute , 用于計(jì)算最終結(jié)果
protected abstract V compute();
​
// Node 3 : 獲取最終結(jié)果
public final V getRawResult() {
        return result;
}
​
// Node 4 : 最終執(zhí)行方法 , 這里是需要調(diào)用具體實(shí)現(xiàn)類compute
protected final boolean exec() {
    result = compute();
    return true;
}

@ 
public class ForkJoinPoolService extends RecursiveTask<Integer> {
​
    private static final int THRESHOLD = 2; //閥值
    private int start;
    private int end;
​
    public ForkJoinPoolService(Integer start, Integer end) {
        this.start = start;
        this.end = end;
    }
​
    @Override
    protected Integer compute() {
        int sum = 0;
        boolean canCompute = (end - start) <= THRESHOLD;
        if (canCompute) {
            for (int i = start; i <= end; i++) {
                sum += i;
            }
        } else {
            int middle = (start + end) / 2;
            ForkJoinPoolService leftTask = new ForkJoinPoolService(start, middle);
            ForkJoinPoolService rightTask = new ForkJoinPoolService(middle + 1, end);
            //執(zhí)行子任務(wù)
            leftTask.fork();
            rightTask.fork();
            //等待子任務(wù)執(zhí)行完，并得到其結(jié)果
            Integer rightResult = rightTask.join();
            Integer leftResult = leftTask.join();
            //合并子任務(wù)
            sum = leftResult + rightResult;
        }
        return sum;
    }
​
}

/**
 * 這是一個(gè)簡(jiǎn)單的Join/Fork計(jì)算過程，將1—1001數(shù)字相加
 */
public class TestForkJoinPool {

    private static final Integer MAX = 200;

    static class MyForkJoinTask extends RecursiveTask<Integer> {
        // 子任務(wù)開始計(jì)算的值
        private Integer startValue;

        // 子任務(wù)結(jié)束計(jì)算的值
        private Integer endValue;

        public MyForkJoinTask(Integer startValue , Integer endValue) {
            this.startValue = startValue;
            this.endValue = endValue;
        }

        @Override
        protected Integer compute() {
            // 如果條件成立，說明這個(gè)任務(wù)所需要計(jì)算的數(shù)值分為足夠小了
            // 可以正式進(jìn)行累加計(jì)算了
            if(endValue - startValue < MAX) {
                System.out.println("開始計(jì)算的部分：startValue = " + startValue + ";endValue = " + endValue);
                Integer totalValue = 0;
                for(int index = this.startValue ; index <= this.endValue  ; index++) {
                    totalValue += index;
                }
                return totalValue;
            }
            // 否則再進(jìn)行任務(wù)拆分，拆分成兩個(gè)任務(wù)
            else {
                MyForkJoinTask subTask1 = new MyForkJoinTask(startValue, (startValue + endValue) / 2);
                subTask1.fork();
                MyForkJoinTask subTask2 = new MyForkJoinTask((startValue + endValue) / 2 + 1 , endValue);
                subTask2.fork();
                return subTask1.join() + subTask2.join();
            }
        }
    }

    public static void main(String[] args) {
        // 這是Fork/Join框架的線程池
        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinTask<Integer> taskFuture =  pool.submit(new MyForkJoinTask(1,1001));
        try {
            Integer result = taskFuture.get();
            System.out.println("result = " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace(System.out);
        }
    }
}

public ForkJoinPool(int parallelism,
                        ForkJoinWorkerThreadFactory factory,
                        UncaughtExceptionHandler handler,
                        boolean asyncMode)

......
asyncMode ? FIFO_QUEUE : LIFO_QUEUE,
......

......
private ForkJoinPool(int parallelism,
                         ForkJoinWorkerThreadFactory factory,
                         UncaughtExceptionHandler handler,
                         int mode,
                         String workerNamePrefix) {
        this.workerNamePrefix = workerNamePrefix;
        this.factory = factory;
        this.ueh = handler;
        this.config = (parallelism & SMASK) | mode;
        long np = (long)(-parallelism); // offset ctl counts
        this.ctl = ((np << AC_SHIFT) & AC_MASK) | ((np << TC_SHIFT) & TC_MASK);
    }
......

package test.thread.pool.merge;

import java.util.Arrays;
import java.util.Random;

/**
 * 歸并排序
 * @author yinwenjie
 */
public class Merge1 {

    private static int MAX = 10000;

    private static int inits[] = new int[MAX];

    // 這是為了生成一個(gè)數(shù)量為MAX的隨機(jī)整數(shù)集合，準(zhǔn)備計(jì)算數(shù)據(jù)
    // 和算法本身并沒有什么關(guān)系
    static {
        Random r = new Random();
        for(int index = 1 ; index <= MAX ; index++) {
            inits[index - 1] = r.nextInt(10000000);
        }
    }

    public static void main(String[] args) {
        long beginTime = System.currentTimeMillis();
        int results[] = forkits(inits); 
        long endTime = System.currentTimeMillis();
        // 如果參與排序的數(shù)據(jù)非常龐大，記得把這種打印方式去掉
        System.out.println("耗時(shí)=" + (endTime - beginTime) + " | " + Arrays.toString(results));       
    }

    // 拆分成較小的元素或者進(jìn)行足夠小的元素集合的排序
    private static int[] forkits(int source[]) {
        int sourceLen = source.length;
        if(sourceLen > 2) {
            int midIndex = sourceLen / 2;
            int result1[] = forkits(Arrays.copyOf(source, midIndex));
            int result2[] = forkits(Arrays.copyOfRange(source, midIndex , sourceLen));
            // 將兩個(gè)有序的數(shù)組，合并成一個(gè)有序的數(shù)組
            int mer[] = joinInts(result1 , result2);
            return mer;
        } 
        // 否則說明集合中只有一個(gè)或者兩個(gè)元素，可以進(jìn)行這兩個(gè)元素的比較排序了
        else {
            // 如果條件成立，說明數(shù)組中只有一個(gè)元素，或者是數(shù)組中的元素都已經(jīng)排列好位置了
            if(sourceLen == 1
                || source[0] <= source[1]) {
                return source;
            } else {
                int targetp[] = new int[sourceLen];
                targetp[0] = source[1];
                targetp[1] = source[0];
                return targetp;
            }
        }
    }

    /**
     * 這個(gè)方法用于合并兩個(gè)有序集合
     * @param array1
     * @param array2
     */
    private static int[] joinInts(int array1[] , int array2[]) {
        int destInts[] = new int[array1.length + array2.length];
        int array1Len = array1.length;
        int array2Len = array2.length;
        int destLen = destInts.length;

        // 只需要以新的集合destInts的長(zhǎng)度為標(biāo)準(zhǔn)，遍歷一次即可
        for(int index = 0 , array1Index = 0 , array2Index = 0 ; index < destLen ; index++) {
            int value1 = array1Index >= array1Len?Integer.MAX_VALUE:array1[array1Index];
            int value2 = array2Index >= array2Len?Integer.MAX_VALUE:array2[array2Index];
            // 如果條件成立，說明應(yīng)該取數(shù)組array1中的值
            if(value1 < value2) {
                array1Index++;
                destInts[index] = value1;
            }
            // 否則取數(shù)組array2中的值
            else {
                array2Index++;
                destInts[index] = value2;
            }
        }

        return destInts;
    }
}

......
/**
 * 使用Fork/Join框架的歸并排序算法
 * @author yinwenjie
 */
public class Merge2 {

    private static int MAX = 100000000;

    private static int inits[] = new int[MAX];

    // 同樣進(jìn)行隨機(jī)隊(duì)列初始化，這里就不再贅述了
    static {
        ......
    }

    public static void main(String[] args) throws Exception {   
        // 正式開始
        long beginTime = System.currentTimeMillis();
        ForkJoinPool pool = new ForkJoinPool();
        MyTask task = new MyTask(inits);
        ForkJoinTask<int[]> taskResult = pool.submit(task);
        try {
            taskResult.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace(System.out);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("耗時(shí)=" + (endTime - beginTime));      
    }

    /**
     * 單個(gè)排序的子任務(wù)
     * @author yinwenjie
     */
    static class MyTask extends RecursiveTask<int[]> {

        private int source[];

        public MyTask(int source[]) {
            this.source = source;
        }

        /* (non-Javadoc)
         * @see java.util.concurrent.RecursiveTask#compute()
         */
        @Override
        protected int[] compute() {
            int sourceLen = source.length;
            // 如果條件成立，說明任務(wù)中要進(jìn)行排序的集合還不夠小
            if(sourceLen > 2) {
                int midIndex = sourceLen / 2;
                // 拆分成兩個(gè)子任務(wù)
                MyTask task1 = new MyTask(Arrays.copyOf(source, midIndex));
                task1.fork();
                MyTask task2 = new MyTask(Arrays.copyOfRange(source, midIndex , sourceLen));
                task2.fork();
                // 將兩個(gè)有序的數(shù)組，合并成一個(gè)有序的數(shù)組
                int result1[] = task1.join();
                int result2[] = task2.join();
                int mer[] = joinInts(result1 , result2);
                return mer;
            } 
            // 否則說明集合中只有一個(gè)或者兩個(gè)元素，可以進(jìn)行這兩個(gè)元素的比較排序了
            else {
                // 如果條件成立，說明數(shù)組中只有一個(gè)元素，或者是數(shù)組中的元素都已經(jīng)排列好位置了
                if(sourceLen == 1
                    || source[0] <= source[1]) {
                    return source;
                } else {
                    int targetp[] = new int[sourceLen];
                    targetp[0] = source[1];
                    targetp[1] = source[0];
                    return targetp;
                }
            }
        }

        private int[] joinInts(int array1[] , int array2[]) {
            // 和上文中出現(xiàn)的代碼一致
        }
    }
}