java 线程分支_Java JUC 多线程 之 ForkJoinPool 分支/合并框架 工作窃取

前言：在工作当中我们在计算一个很大值加上一个很大的值等等计算的时候，这时候计算机在串行计算的时候就很耗CPU，效率也很低

这时候我们可以选择多线程分支合并 利用多个线程去计算，然后将最后各个线程的结果合并最终的结果

ForkJoinPool分支/合并框架 工作窃取

Fork/Join 框架：就是在必要的情况下，将一个大任务，进行拆分(fork)成 若干个小任务(拆到不可再拆时)，再将一个个的小任务运算的结果进 行 join 汇总。

如图：

Fork/Join 框架与线程池的区别

 采用 “工作窃取”模式(work-stealing)： 当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加 到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队 列中。

 相对于一般的线程池实现，fork/join框架的优势体现在对其中包含的任务 的处理方式上.在一般的线程池中，如果一个线程正在执行的任务由于某些 原因无法继续运行，那么该线程会处于等待状态。而在fork/join框架实现中， 如果某个子问题由于等待另外一个子问题的完成而无法继续运行。那么处理 该子问题的线程会主动寻找其他尚未运行的子问题来执行.这种方式减少了 线程的等待时间，提高了性能。

不多说，看代码：

packagecom.atxiaodei.javajuc.jucdemo;

importorg.junit.Test;

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

/***@authorwangmeng*@date2020/9/23* ForkJoinPool分支/合并框架 工作窃取*前言：在工作当中我们在计算一个很大值加上一个很大的值等等计算的时候，这时候计算机在串行计算的时候就很耗CPU，效率也很低，这时候我们可以选择*多线程分支合并 利用多个线程去计算，然后将最后各个线程的结果合并最终的结果**/public classTestForkJoinPool线程分支合并{

public static voidmain(String[]args) {// 1.8特性获取计算Instant start = Instant.now();

ForkJoinPool pool = newForkJoinPool();

ForkJoinTasktask = newForkJoinSumCalculate(0L,50000000000L);

Long sum = pool.invoke(task);

System.out.println(sum);

Instant end = Instant.now();

System.out.println("耗费时间为："+ Duration.between(start,end).toMillis());//166-1996-10590}

@Testpublic voidtest1(){Instant start = Instant.now();

longsum = 0L;

for(longi = 0L;i <= 50000000000L;i++) {sum += i;}

System.out.println(sum);

Instant end = Instant.now();

System.out.println("耗费时间为："+ Duration.between(start,end).toMillis());//35-3142-15704}

//java8新特性@Testpublic voidtest2(){Instant start = Instant.now();

Long sum = LongStream.rangeClosed(0L,50000000000L).parallel().reduce(0L,Long::sum);

System.out.println(sum);

Instant end = Instant.now();

System.out.println("耗费时间为："+ Duration.between(start,end).toMillis());//1536-8118}

}

//继承RecursiveTask实现compute方法完成分支合并classForkJoinSumCalculate extendsRecursiveTask {

private static final longserialVersionUID= -259195479995561737L;

private longstart;private longend;

private static final longTHURSHOLD= 10000L;//临界值

publicForkJoinSumCalculate(longstart, longend) {this.start= start;this.end= end;}

@OverrideprotectedLong compute() {longlength = end- start;

if(length <= THURSHOLD){longsum = 0L;

for(longi = start;i <= end;i++) {sum += i;}

returnsum;}else{longmiddle = (start+ end)/ 2;

ForkJoinSumCalculate left = newForkJoinSumCalculate(start,middle);//进行拆分(这里看不到到底在哪个里面计算的值呢？好好想，好看，//上面的概念，(拆到不可再拆时，也就是当前length小于等于10000L的时候进行计算))，同时压入线程队列left.fork();

ForkJoinSumCalculate right = newForkJoinSumCalculate(middle+1,end);right.fork();//进行拆分，同时压入线程队列

returnleft.join()+ right.join();}}

}

运行代码，完成总结：

在进行小数值计算的时候，效率  java8新特性Stream

在进行大数值特别大的计算的时候，效率 ForkJoinPool 分支合并< java8新特性Stream

大数值 ForkJoinPool 分支合并效率最好，Steam还行，for迭代器特别卡，执行半分钟

详细更多JUC 多线程 代码地址：