1.引言:
现在,硬件的处理能力,基本处于水平发展,为了更好的提高性能,现在都是采用的多核CPU,尽可能的提升并发性能,但是有一个问题是程序的本身并发处理能力不强,就会造成不能够合理的利用多核心资源,例如,多个线程运行时,一个CPU分配的任务较少,当该CPU完成其任务后,处于空闲状态,这就浪费了资源。
在JDK7时,引入了ForkJoinPool,是一个线程池,其核心的思想是将一个大任务拆分成小任务,然后将每个小任务的结果汇总到一个结果上。它本身是一个线程池,其所支持的最大线程数,就是硬件的CPU的数量,是AbstractExecutorService的子类,并引入了“工作窃取算法”,使其在多线程并行处理的效果上更佳,如下图所示:
1.1 工作窃取算法
work-stealing(工作窃取),ForkJoinPool提供了一个更有效的利用线程的机制,当ThreadPoolExecutor还在用单个队列存放任务时,ForkJoinPool已经分配了与线程数相等的队列,当有任务加入线程池时,会被平均分配到对应的队列上,各线程进行正常工作,当有线程提前完成时,会从队列的末端“窃取”其他线程未执行完的任务,当任务量特别大时,CPU多的计算机会表现出更好的性能。
2.常用方法:
ForkJoin框架,必须先创建一个ForkJoin任务。它提供了分而治之的操作机制,即在提供的任务中执行fork()和join()的操作机制,通常我们不直接继承ForkJoinTask类,而是继承其两个子类:
1. RecursiveTask<T>:用于有返回值结果的任务。
2. RecursiveAction:用于没有返回结果的任务。
ForkJoinPool :ForkJoinTask需要通过ForkJoinPool来执行,任务分割出的子任务会添加到当前工作线程所维护的双端队列中,进入队列的头部。当一个工作线程的队列里暂时没有任务时,它会随机从其他工作线程的队列的尾部获取一个任务。
3.实例:
求一个数组中的最大值
比较了“常规算法”和“利用ForkJoin框架所需的时间”
package com.it.thread;
import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
public class TestForkJoinMax {
public static void main(String[] args) {
int[] data = new int[40000000];
Random random = new Random();
for(int i = 0 ;i<data.length;i++) {
data[i]=random.nextInt(100000000);
}
System.out.println(findMax1(data));
System.out.println(findMax2(data));
}
static int findMax1(int data[]) {
int max = data[0];
long t1 = System.nanoTime();
for(int i = 1;i<data.length;i++) {
if (max<data[i]) {
max=data[i];
}
}
long t2 = System.nanoTime();
System.out.println(t2-t1);
return max;
}
static int findMax2(int data[]) {
class MyFindMax extends RecursiveTask<Integer>{
int data[];
int start;//包含数组的起始下标
int end;//不包含结束下标
//设置一个阈值,当作条件进行大任务的拆分条件
static final int THRESHOLD=100000;
public MyFindMax(int[] data, int start, int end) {
super();
this.data = data;
this.start = start;
this.end = end;
}
@Override
protected Integer compute() {
//小于阈值,直接利用常规算法,进行最大值寻找
if (end-start<=THRESHOLD) {
int max = data[start];
for(int i = start+1;i<end;i++) {
if (max<data[i]) {
max=data[i];
}
}
return max;
}else {
//如果大于阈值,进分裂成两个子任务处理
int middle = (start+end)/2;
MyFindMax task1 = new MyFindMax(data, start, middle);
MyFindMax task2 = new MyFindMax(data, middle, end); //执行两个子任务
invokeAll(task1, task2);
//获取子任务的返回值
int result1 =task1.join();
int result2 =task2.join();
if (result2>result1) {
return result2;
}else {
return result1;
}
}
}
}
long t1 = System.nanoTime();
//创建ForkJoinPool 线程池
ForkJoinPool pool = new ForkJoinPool();
MyFindMax main = new MyFindMax(data, 0, data.length);
//将大任务提交给线程池
int result = pool.invoke(main);
long t2 = System.nanoTime();
System.out.println(t2-t1);
return result;
}
}
运行结果:
31780336
99999996
29180490
99999996
第一行:常规算法所需的时间(纳秒为单位)已经是最优的算法了
第二行:常规算法所计算的最大值
第三行:ForkJoin框架运算所需时间(纳秒为单位)
第四行:ForkJoin框架所计算的最大值
很明显可以看出ForkJoin并行框架使用的时间少,说明其并行运行的效率很高。
4.对ForkJoin框架的常见优化方法:
1.尽量选取一个适合的阈值。
2.分裂为子任务时,都需要创建对象,可以在此位置进行优化。