ForkJoinPool的理解与使用

ForkJoinPool充分利用多cpu的优势，把一个任务拆分成多个“小任务”，把多个“小任务”放到多个处理器上并行执行；当多个“小任务”执行完成之后，再将这些执行结果合并起来。感觉有点像二分法。

ForkJoinPool 的工作特点 是“工作窃取”，何为工作窃取，ForkJoinPool底层维护着一个双端队列，当一个线程的任务队列执行完毕后，其他线程的任务队列还没有执行完毕，这时，已经执行完毕的线程就会到另一个线程的双端任务队列的尾部去偷取任务执行。

简单应用

import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.stream.LongStream;

/**
 * @Auther: 罗罗
 * @Description:
 */
public class Test04 {
    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> mytask = new Mytask(0L,100000L);
        Long result = forkJoinPool.invoke(mytask);
        System.out.println(result);
        //释放资源
        forkJoinPool.shutdown();
    }

    public void test(){
        Instant start = Instant.now();
        long sum = 0;
        for (long i = 0 ; i <100000; i++) {
            sum+=i;
        }
        Instant end = Instant.now();
        System.out.println(sum+" 的执行时间为："+ Duration.between(start,end).toMillis());
    }

    //java8
    public void test2(){
        long sum = LongStream.rangeClosed(0L,100000L)
                .parallel()
                .reduce(0L,Long::sum);
        System.out.println(sum);
    }
}

class  Mytask extends RecursiveTask<Long>{

    private long start;
    private long end;
    private final long thrould = 200L;//阈值


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

    @Override
    protected Long compute() {
        long sum =0;
        //如果小于阈值，就不需要拆分
        if (end - start <= thrould){
            for (long i = start; i < end; i++) {
                sum += i;
            }
            return sum;
        }else {
            long middle = (start+end)/2;

            //开始进行二分
            Mytask left = new Mytask(start, middle);
            left.fork();//进行拆分，同时压入线程队列

            Mytask right = new Mytask(middle+1, end);
            right.fork();
            //合并结果
            return left.join()+right.join();
        }
    }
}

注意：ForkJoinPool也会产生竞争，比如，两个空闲的线程争抢一个资源。