forkJoinPool什么适合cpu密集型
1、无同步,各个工作线程维护自身的的工作队列,而不共享一个队列,无需锁等同步措施
2、线程数应与硬件对应,尽量减少线程状态切换带来的性能浪费
3、线程窃取
先看个例子
public class ForkJoinSumCalculator extends RecursiveTask<Long> {
//要求和的数组
private final long[] numbers;
//子任务处理的数组开始和终止的位置
private final int start;
private final int end;
//不在将任务分解成子任务的阀值大小
public static final int THRESHOLD = 10000;
//用于创建组任务的构造函数
public ForkJoinSumCalculator(long[] numbers){
this(numbers, 0, numbers.length);
}
//用于递归创建子任务的构造函数
public ForkJoinSumCalculator(long[] numbers,int start,int end){
this.numbers = numbers;
this.start = start;
this.end = end;
}
//重写接口的方法
@Override
protected Long compute() {
//当前任务负责求和的部分的大小
int length = end - start;
//如果小于等于阀值就顺序执行计算结果
if(length <= THRESHOLD){
return computeSequentially();
}
//创建子任务来为数组的前一半求和
ForkJoinSumCalculator leftTask = new ForkJoinSumCalculator(numbers, start, start + length/2);
//将子任务拆分出去,丢到ForkJoinPool线程池异步执行。
leftTask.fork();
//创建子任务来为数组的后一半求和
ForkJoinSumCalculator rightTask = new ForkJoinSumCalculator(numbers, start + length/2, end);
//第二个任务直接使用当前线程计算而不再开启新的线程。
long rightResult = rightTask.compute();
//读取第一个子任务的结果,如果没有完成则等待。
long leftResult = leftTask.join();
//合并两个子任务的计算结果
return rightResult + leftResult;
}
//顺序执行计算的简单算法
private long computeSequentially(){
long sum = 0;
for(int i =start; i< end; i++){
sum += numbers[i];
}
return sum;
}
//提供给外部使用的入口方法
public static void main(String[] args) {
long[] numbers = LongStream.rangeClosed(1, 100000).toArray();
ForkJoinTask<Long> task = new ForkJoinSumCalculator(numbers);
System.out.println(new ForkJoinPool().invoke(task));
}
}
ForkJoinPool 的每个工作线程都维护着一个工作队列(WorkQueue),这是一个双端队列(Deque),里面存放的对象是任务(ForkJoinTask)。
每个工作线程在运行中产生新的任务(通常是因为调用了 fork())时,会放入工作队列的队尾,并且工作线程在处理自己的工作队列时,使用的是 LIFO 方式,也就是说每次从队尾取出任务来执行。
每个工作线程在处理自己的工作队列同时,会尝试窃取一个任务(或是来自于刚刚提交到 pool 的任务,或是来自于其他工作线程的工作队列),窃取的任务位于其他线程的工作队列的队首,也就是说工作线程在窃取其他工作线程的任务时,使用的是 FIFO 方式。
在遇到 join() 时,如果需要 join 的任务尚未完成,则会先处理其他任务,并等待其完成。
在既没有自己的任务,也没有可以窃取的任务时,进入休眠。
这也说明了,forkJoinPool适合cpu密集型计算而不是太过耗时io密集型计算.