分而治之
fork/Join框架的思想是将一个规模为n的大任务,fork成几个规模较小的K个子任务,最后合并所有子任务的结果,返回最终结果。
工作窃取
如图一个规模为T的任务划分成12个子任务,分别有4个线程在执行。如果当前线程没有可执行任务时,会从其他线程的任务队列中窃取任务来执行。工作窃取算法保证了cpu不会处于空闲状态。
ForkJoin用法
1.带返回值RecursiveTask
public class MySumTask extends RecursiveTask<Integer> {
private int[] data;
private int begin;
private int end;
@Override
protected Integer compute() {
//最小划分粒度
if (end-begin<=2){
int result=0;
for (int i = begin; i <end ; i++) {
result+=data[i];
}
return result;
}
int middle=(begin+end)/2;
MySumTask left=new MySumTask(data,begin,middle);
left.fork();
MySumTask right=new MySumTask(data,middle,end);
right.fork();
return left.join()+right.join();
}
打印统计结果
public static void main(String[] args) {
int[] dataArr=new int[]{1,2,3,4,6,7,8};
MySumTask mySumTask=new MySumTask(dataArr,0,dataArr.length);
ForkJoinPool pool=new ForkJoinPool();
System.out.println("sum result="+pool.invoke(mySumTask));
}
2.无返回值RecursiveAction
public class MyPrintTask extends RecursiveAction {
private int[] data;
private int begin;
private int end;
@Override
protected void compute() {
//最小划分粒度
if (end-begin<=2){
StringBuilder builder=new StringBuilder("[");
for (int i = begin; i <end ; i++) {
builder.append(data[i]).append(",");
}
System.out.println("打印数组:"+builder.substring(0,builder.length()-1)+"]");
return;
}
int middle=(begin+end)/2;
MyPrintTask left=new MyPrintTask(data,begin,middle);
left.fork();
MyPrintTask right=new MyPrintTask(data,middle,end);
right.fork();
}
等待所有任务执行结束
public static void main(String[] args) throws Exception{
int[] dataArr=new int[]{1,2,3,4,6,7,8};
MyPrintTask mySumTask=new MyPrintTask(dataArr,0,dataArr.length);
ForkJoinPool pool=new ForkJoinPool();
//提交任务
pool.submit(mySumTask);
//等待所有任务完成
pool.awaitTermination(2, TimeUnit.SECONDS);
}
Java8 Stream并行流的Fork/Join框架使用
如下所示代码,利用Java8的并行流,对1到5的数进行相乘
public static void main(String[] args) {
Stream.of(1,2,3,4,5).parallel().reduce((x, y)->x*y).ifPresent(System.out::println);
}
1.parallel()方法设置标志位
设置了sourceStage.parallel 值为true
abstract class AbstractPipeline{
@Override
@SuppressWarnings("unchecked")
public final S parallel() {
sourceStage.parallel = true;
return (S) this;
}
}
2.reduce()方法根据标志位来判断是否并行
evaluate方法,会调用isParallel(),对上面的sourceStage.parallel进行判断
abstract class ReferencePipeline{
@Override
public final Optional<P_OUT> reduce(BinaryOperator<P_OUT> accumulator) {
return evaluate(ReduceOps.makeRef(accumulator));
}
final <R> R evaluate(TerminalOp<E_OUT, R> terminalOp) {
// 判断sourceStage.parallel是否为true
return isParallel()
? terminalOp.evaluateParallel(this, sourceSpliterator(terminalOp.getOpFlags()))
: terminalOp.evaluateSequential(this, sourceSpliterator(terminalOp.getOpFlags()));
}
}
3.terminalOp的接口以及实现类
接口TerminalOp
interface TerminalOp<E_IN, R> {
default <P_IN> R evaluateParallel(PipelineHelper<E_IN> helper,
Spliterator<P_IN> spliterator) {
if (Tripwire.ENABLED)
Tripwire.trip(getClass(), "{0} triggering TerminalOp.evaluateParallel serial default");
return evaluateSequential(helper, spliterator);
}
}
实现类ReduceOps新建了ReduceTask对象
final class ReduceOps {
@Override
public <P_IN> R evaluateParallel(PipelineHelper<T> helper,
Spliterator<P_IN> spliterator) {
return new ReduceTask<>(this, helper, spliterator).invoke().get();
}
}
对ReduceTask进行代码追踪,最后会追踪到ForkJoinTask类中,invoke方法是ForkJoinTask()的invoke()方法
结论
由此我们可以看出,Java8的Stream并行流底层代码,确实采用了Fork/Join框架来实现