Fork-Join分治编程介绍（一）

//普通线程池下实现的分治效果测试
public class CommonThreadPoolTest {
    //固定大小的线程池，池中线程数量为3
    static ExecutorService fixPoolExcutor = Executors.newFixedThreadPool(3);

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //计算 1+2+...+10  的结果
        CountTaskCallable task = new CountTaskCallable(1,10);
        //提交主人翁
        Future<Integer> future = fixPoolExcutor.submit(task);
        System.out.println("计算的结果："+future.get());
    }
}

class CountTaskCallable implements Callable<Integer> {

    //设置阀值为2
    private static final int THRESHOLD = 2;
    private int start;
    private int end;

    public CountTaskCallable(int start, int end) {
        super();
        this.start = start;
        this.end = end;
    }

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        //判断任务的大小是否超过阀值
        boolean canCompute = (end - start) <= THRESHOLD;
        if (canCompute) {
            for (int i = start; i <= end; i++) {
                sum += i;
            }
        } else {
            System.out.println("切割的任务："+start+"加到"+end+"   执行此任务的线程是 "+Thread.currentThread().getName());
            int middle = (start + end) / 2;
   
            CountTaskCallable leftTaskCallable = new CountTaskCallable(start, middle);
            CountTaskCallable rightTaskCallable = new CountTaskCallable(middle + 1, end);
            // 将子任务提交到线程池中
            Future<Integer> leftFuture = CommonThreadPoolTest.fixPoolExcutor.submit(leftTaskCallable);
            Future<Integer> rightFuture = CommonThreadPoolTest.fixPoolExcutor.submit(rightTaskCallable);
            //阻塞等待子任务的执行结果
            int leftResult = leftFuture.get();
            int rightResult = rightFuture.get();
            // 合并子任务的执行结果
            sum = leftResult + rightResult;
            
        }
        return sum;
    }

}

if 任务足够小
    直接返回结果
else
    分割成N个子任务
    依次调用每个子任务的fork方法执行子任务
    依次调用每个子任务的join方法合并执行结果

public class CountTest {
    public static void main(String[] args) throws InterruptedException, ExecutionException {

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        //创建一个计算任务，计算 由1加到12
        CountTask countTask = new CountTask(1, 12);
        Future<Integer> future = forkJoinPool.submit(countTask);
        System.out.println("最终的计算结果："+future.get());
    }
}

class CountTask extends RecursiveTask<Integer>{

    private static final int THRESHOLD = 2;
    private int start;
    private int end;
    
    
    public CountTask(int start, int 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;
            }
            System.out.println("执行计算任务，计算    "+start+"到 "+end+"的和  ，结果是："+sum+"   执行此任务的线程："+Thread.currentThread().getName());

        }else{ //任务过大，需要切割
            System.out.println("任务过大，切割的任务：  "+start+"加到 "+end+"的和       执行此任务的线程："+Thread.currentThread().getName());
            int middle = (start+end)/2;
            //切割成两个子任务
            CountTask leftTask = new CountTask(start, middle);
            CountTask rightTask = new CountTask(middle+1, end);
            //执行子任务
            leftTask.fork();
            rightTask.fork();
            //等待子任务的完成，并获取执行结果
            int leftResult = leftTask.join();
            int rightResult = rightTask.join();
            //合并子任务
            sum = leftResult+rightResult;
        }
        return sum;
    }
}