Java 7开始引入了一种新的Fork/Join线程池,它可以执行一种特殊的任务:把一个大任务拆成多个小任务并行执行。
比如要计算一个超大数组的和,最简单的做法是用一个循环在一个线程内完成:
┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─
还有一种方法,可以把数组拆成两部分,分别计算,最后加起来就是最终结果,这样可以用两个线程并行执行:
┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
如果拆成两部分还是很大,我们还可以继续拆,用4个线程并行执行:
┌─┬─┬─┬─┬─┬─┐
└─┴─┴─┴─┴─┴─┘
┌─┬─┬─┬─┬─┬─┐
└─┴─┴─┴─┴─┴─┘
┌─┬─┬─┬─┬─┬─┐
└─┴─┴─┴─┴─┴─┘
┌─┬─┬─┬─┬─┬─┐
└─┴─┴─┴─┴─┴─┘
这就是Fork/Join任务的原理:判断一个任务是否足够小,如果是,直接计算,否则,就分拆成几个小任务分别计算。这个过程可以反复“裂变”成一系列小任务。
1、ForkJoinPool
既然任务是被逐渐的细化的,那就需要把这些任务存在一个池子里面,这个池子就是ForkJoinPool,它与其它的ExecutorService区别主要在于它使用“工作窃取“,那什么是工作窃取呢?
一个大任务会被划分成无数个小任务,这些任务被分配到不同的队列,这些队列有些干活干的块,有些干得慢。于是干得快的,一看自己没任务需要执行了,就去隔壁的队列里面拿去任务执行。
2、ForkJoinTask
ForkJoinTask就是ForkJoinPool里面的每一个任务。他主要有两个子类:RecursiveAction和RecursiveTask。然后通过fork()方法去分配任务执行任务,通过join()方法汇总任务结果,
(1)RecursiveAction 一个递归无结果的ForkJoinTask(没有返回值)
(2)RecursiveTask 一个递归有结果的ForkJoinTask(有返回值)
ForkJoinPool由ForkJoinTask数组和ForkJoinWorkerThread数组组成,ForkJoinTask数组负责存放程序提交给ForkJoinPool的任务,而ForkJoinWorkerThread数组负责执行这些任务。
RecursiveTask 案例
package com.concurrency3.forkjoin;
import java.util.concurrent.*;
import java.util.stream.IntStream;
/**
*
*/
public class ForkJoinRecursiveTask {
private final static int MAX_THRESHOLD = 3;
// RecursiveTask 一个递归有结果的ForkJoinTask(有返回值)
private static class CalculatedRecursiveTask extends RecursiveTask<Integer>{
private final int start;
private final int end;
private CalculatedRecursiveTask(int start, int end) {
this.start = start;
this.end = end;
}
@Override
protected Integer compute() {
if(end - start<=MAX_THRESHOLD){// 如果任务足够小,直接计算:
//rangeClosed包含结束节点,是闭合的
return IntStream.rangeClosed(start,end).sum();
}else {// 任务太大,一分为二:
int middle = (start+end)/2;
CalculatedRecursiveTask leftTask = new CalculatedRecursiveTask(start,middle);
CalculatedRecursiveTask rightTask = new CalculatedRecursiveTask(middle+1,end);
leftTask.fork();
rightTask.fork();
return leftTask.join()+rightTask.join();
}
}
}
public static void main(String[] args) {
final ForkJoinPool forkJoinPool = new ForkJoinPool();
Integer result = forkJoinPool.invoke(new CalculatedRecursiveTask(0, 100));
System.out.println(result);
// ForkJoinTask implements Future
ForkJoinTask<Integer> future = forkJoinPool.submit(new CalculatedRecursiveTask(0, 100));
try {
Integer result1 = future.get();
System.out.println(result1);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
RecursiveAction 案例
package com.concurrency3.forkjoin;
import sun.print.SunMinMaxPage;
import java.util.Optional;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.IntStream;
/**
* @Author yxc
*/
public class ForkJoinRecursiveAction {
private final static int MAX_THRESHOLD = 3;
private final static AtomicInteger SUM = new AtomicInteger(0);
private static class CalculateRecursiveAction extends RecursiveAction{
private final int start;
private final int end;
private CalculateRecursiveAction(int start, int end) {
this.start = start;
this.end = end;
}
@Override
protected void compute() {
if(end - start<=MAX_THRESHOLD){// 如果任务足够小,直接计算:
//rangeClosed包含结束节点,是闭合的
SUM.addAndGet(IntStream.rangeClosed(start,end).sum());
}else {// 任务太大,一分为二:
int middle=(start+end)/2;
CalculateRecursiveAction leftAction = new CalculateRecursiveAction(start,middle);
CalculateRecursiveAction rightAction = new CalculateRecursiveAction(middle+1,end);
leftAction.fork();
rightAction.fork();
}
}
}
public static void main(String[] args) {
final ForkJoinPool forkJoinPool = new ForkJoinPool();
/* forkJoinPool.invoke(new CalculateRecursiveAction(0, 100));
try {
forkJoinPool.awaitTermination(10000, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(SUM);*/
forkJoinPool.submit(new CalculateRecursiveAction(0,100));//没有返回值
try {
forkJoinPool.awaitTermination(10,TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
Optional.of(SUM).ifPresent(System.out::println);
}
}
ForkJoinTask在执行的时候可能会抛出异常,在主线程中是无法直接获取的,但是可以通过ForkJoinTask提供的isCompletedAbnormally()方法来检查任务是否已经抛出异常或已经被取消了。
参考链接:https://www.liaoxuefeng.com/wiki/1252599548343744/1306581226487842
https://baijiahao.baidu.com/s?id=1649619201425234676&wfr=spider&for=pc