Fork/Join个人小结

主要的类：

1、RecursiveTask：

1）  RecursiveTask<T>：表示一个“任务”，重写他的T  compute()方法，计算返回值；

2）  RecursiveTask<T>有个fork()方法，表示启动、分发；

3）  RecursiveTask<T>有个T  join()方法，表示等待、同步等待结果；

2、ForkJoinPool：

1）new ForkJoinPool（int）：int表示启动线程数，默认为CPU的线程数；

2）T  invoke（RecursiveTask）：启动根任务；

主要开发步骤：

1、定义任务，至少有两种类型的任务，按可分和不可分来辨别；

2、编写各种任务的class，主要难点在可分任务那里，要加if判断，判断要fork成哪种类型的任务，并且在fork之前将任务保存在一个list中

3、每个可分任务最后都要将子任务list给for-each出来，并且执行join得到各个子任务的结果进行处理后返回；

4、使用ForkJoinPool的invoke，将根任务放进去，然后就能返回结果了；

Demo：

class SmallTask extends RecursiveTask<Long> {
    private long[] nums;

    public SmallTask(long[] nums) {
        this.nums = nums;
    }

    @Override
    protected Long compute() {
        Long n = 0L;
        for (long i : nums)
            n += i;
        return n;
    }
}

class BigTask extends RecursiveTask<Long> {
    private long[] nums;

    public BigTask(long[] nums) {
        this.nums = nums;
    }

    @Override
    protected Long compute() {
        List<RecursiveTask<Long>> list = new ArrayList<RecursiveTask<Long>>();
        if (nums.length <= 2) {
            SmallTask task = new SmallTask(nums);
            list.add(task);
            task.fork();
        } else {
            long[] nums1 = Arrays.copyOfRange(nums, 0, nums.length / 2);
            long[] nums2 = Arrays.copyOfRange(nums, nums.length / 2, nums.length);
            BigTask task1 = new BigTask(nums1);
            BigTask task2 = new BigTask(nums2);
            list.add(task1);
            list.add(task2);
            task1.fork();
            task2.fork();
        }

        long n = 0L;
        for (RecursiveTask<Long> r : list) {
            n += r.join();
        }
        return n;
    }
}

public class Demo {

    public static void main(String[] args) {
        long[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        ForkJoinPool pool = new ForkJoinPool(8);
        long result = pool.invoke(new BigTask(nums));

        System.out.println(result);
    }

}