简单使用 Fork/Join 框架

1、

package multiThread.art;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

/**
 * 需求是： 计算 1+2+3+4 的结果
 * 分割上面的计算任务，并希望每个子任务最多执行两个数的相加
 *
 *  1）RecursiveTask 是 ForkJoinTask 的子类
 *  2） ForkJoinTask 与一般任务的主要区别在于： 它需要实现 compute 方法。
 *  3） compute 方法，首先需要判断任务是否足够小，如果足够小就直接执行任务。
 *      如果不够小，就必须分割成两个子任务，每个子任务在调用 fork()方法的时候，
 *      又会进入 compute() 方法，看看当前子任务是否需要继续分割成子任务，如果不需要
 *      继续分割，则执行当前任务并返回结果
 *  4） 使用 join 方法会等待子任务执行完并得到其结果。
 */

public class CountTask extends RecursiveTask<Integer> {
    /**
     * 阀值
     */
    private static final int THRESHOLD = 2;
    private int start;
    private int end;
    public CountTask(int strat , int end){
        this.start = strat;
        this.end = end;
    }
    /**
     * 必须重写的方法
     * @return
     */
    @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;
            CountTask leftTask = new CountTask(start , middle);
            CountTask rightTask = new CountTask(middle +1  , end);
            /**
             * 执行子任务
             */
            leftTask.fork();
            rightTask.fork();
            /**
             * 等待子任务执行完，并得到其结果
             */
            Integer leftResult = leftTask.join();
            Integer rightResult = rightTask.join();
            /**
             * 合并子任务
             */
            sum = leftResult + rightResult;
        }
        return sum;
    }

    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        /**
         * 生成一个计算任务，负责计算 1+2+3+4
         */
        CountTask task = new CountTask(1,4);
        /**
         * 执行一个任务
         */
        ForkJoinTask<Integer> result = forkJoinPool.submit(task);
        try {
            System.out.println(result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}