并发编程八-ForkJoin

ForkJoinPool

该线程池中的线程如果空闲了的时候，会通过工作窃取去执行其他任务队列的等待任务，实现任务的高效处理。

如果有一个任务可以拆分成多个小任务，提交到ForkJoinPool线程池去执行，那么可以让该任务更高效的被执行。

1，需求：

举个例子，比如现在要把从0到30亿这些数字求和，一般的做法就是使用个for循环来依次相加处理。

但是如果用Fork/Join的方式来执行的话，就可以把求和操作拆分成多个小任务来执行，然后把每个小任务计算的结果相加，最终就可以得到求和的结果。

2，代码实现：

代码中有注释说明。这里就不重复。

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

public class ForkJoinDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 需求：从0加到30亿
        long start = 0L;
        long end = 3000000000L;
        long result = 0;
        // 方式一：使用for循环
        long t1 = System.currentTimeMillis();
        for(long i=start; i<=end; i++){
            result +=i;
        }
        long t2 = System.currentTimeMillis();
        System.out.println("方式一计算结果："+result+"，耗时："+(t2-t1));
        // 方式二：使用fork/join
        ForkJoinPool forkJoinPool = new ForkJoinPool();// 创建默认的ForkJoin线程池
        RecursiveTaskData taskData = new RecursiveTaskData(start, end);// 创建任务（该任务里会自动拆分任务）
        ForkJoinTask<Long> submit = forkJoinPool.submit(taskData);// 提交任务到线程池
        result = submit.get();// 获取计算结果
        long t3 = System.currentTimeMillis();
        System.out.println("方式二计算结果："+result+"，耗时："+(t3-t2));
        // 方式三：使用Stream并行流
        result = LongStream.rangeClosed(start, end).parallel().reduce(0, Long::sum);
        long t4 = System.currentTimeMillis();
        System.out.println("方式三计算结果："+result+"，耗时："+(t4-t3));
    }
}

class RecursiveTaskData extends RecursiveTask<Long> {

    private long start;
    private long end;
    private static long threshold = 10000L;// 阈值（当计算的个数超过该值时需要拆分任务）

    public RecursiveTaskData(long start, long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        // 如果任务不大，则直接计算
        if((end-start)<threshold){
            long res = 0;
            for(long j = start;j<=end;j++){
                res +=j;
            }
            return res;
        }else{// 如果计算任务比较大，则把任务拆分成两个小任务来执行（）递归调用
            long middle = (start+end)/2;
            RecursiveTaskData task1 = new RecursiveTaskData(start, middle);
            RecursiveTaskData task2 = new RecursiveTaskData(middle+1, end);
            task1.fork();
            task2.fork();
            return task1.join()+task2.join();
        }
    }
}

3，运行结果：

使用单线程依次相加的计算方式最慢。

使用fok/join的方式，把任务拆分为多个小任务计算，然后把小任务的结果依次返回并相加，得到最终结果。

使用jdk提供的并行流计算。

方式一计算结果：4500000001500000000，耗时：1658
方式二计算结果：4500000001500000000，耗时：587
方式三计算结果：4500000001500000000，耗时：374

4，小结

fork/join框架可以将一个大任务分割成若干小任务，最终汇总每个小任务的结果得到这个大任务的结果。它虽然不能适应所有的并发情况,但是在它的适用范围之内，它能够轻松的利用多个CPU提供的计算资源来协作完成一个复杂的计算任务。

• ForkJoinPool:用于处理workerThread和workQueue队列的创建和分配，每当创建一个workerThread，则分配一个对应的workQueue。
• WorkerThread：从workQueue里面取出任务出来处理。
• WorkQueue: 是一个双端队列，负责存储接收的任务。
• ForkJoinTask：提交的任务，有两个子类分别是RecursiveTask和RecursiveAction。RecursiveTask任务是有返回值，RecursiveAction没有返回值。