一、fork/join框架的理念
1、分而治之
规模为N的问题,当N<阈值的时候,可以直接处理解决。当N>阈值,将N分解为K个小规模子问题。子问题需互相独立,要与原问题形式相同,递归的解决子问题,合并子问题的解,得到原问题的解。
1、工作密取
线程做完当前任务后,需要去获取剩余子问题来解决,提高解决问题的效率。取任务时是在任务队列中的尾部取,防止线程之间的竞争。
二、fork/join的标准范式
三、fork/join两种使用方式
1、同步用法+返回结果值
同步:poll.invoke(sumTask);执行完成。也就是正在任务都执行完成之后,主线程才会继续进行执行,否则主线程会一只阻塞等待ForkJoin。如果任务执行时间较长,则会使主线程一只阻塞,效率和系统响应不及时。
下面是计算一个数组的累加和的程序(用同步fork/join框架实现)
package cn.enjoy.controller.thread.ForkJoin;
import java.util.Random;
/**
* @author:wangle
* @description:生成一个数组
* @version:V1.0
* @date:2020-03-19 17:44
**/
public class MakeArray {
public static final Integer SIZE = 4000;
public static int[] getArray(){
Random r = new Random();
int[] result = new int[SIZE];
for(int i=0;i<SIZE;i++){
result[i] = r.nextInt(SIZE*3);
}
return result;
}
}
package cn.enjoy.controller.thread.ForkJoin;
import cn.enjoy.controller.thread.DBPOLL.SleepTools;
/**
* @author:wangle
* @description:数组累加
* @version:V1.0
* @date:2020-03-19 17:49
**/
public class AddSum {
public static void main(String[] args){
int[] arry = MakeArray.getArray();
long time = System.currentTimeMillis();
int count = 0;
for(int i=0;i<MakeArray.SIZE;i++){
SleepTools.ms(1);
count+=arry[i];
}
long endTime = System.currentTimeMillis();
System.out.println(count+"\n");
System.out.println("耗时:"+String.valueOf(endTime-time));
}
}
结果
package cn.enjoy.controller.thread.ForkJoin;
import cn.enjoy.controller.thread.DBPOLL.SleepTools;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
/**
* @author:wangle
* @description:累加
* @version:V1.0
* @date:2020-03-19 17:55
**/
public class ForkJoinAdd {
private static class SumTask extends RecursiveTask<Integer> {
private static final Integer limit = MakeArray.SIZE/10;
private int[] arry;
private int startIndex;
private int endIndex;
public SumTask(int[] arry,int startIndex,int endIndex){
this.arry=arry;
this.startIndex=startIndex;
this.endIndex=endIndex;
}
@Override
protected Integer compute(){
if(endIndex-startIndex<limit){
int count=0;
for(int i=startIndex;i<=endIndex;i++){
SleepTools.ms(1);
count+=arry[i];
}
return count;
}else {
int mid =(endIndex+startIndex)/2;
SumTask sumTaskLeft = new SumTask(arry,startIndex,mid);
SumTask sumTaskRight = new SumTask(arry,mid+1,endIndex);
invokeAll(sumTaskLeft,sumTaskRight);
return sumTaskLeft.join()+sumTaskRight.join();
}
}
}
public static void main(String[] args){
ForkJoinPool poll = new ForkJoinPool();
long time = System.currentTimeMillis();
int[] arry = MakeArray.getArray();
SumTask sumTask = new SumTask(arry,0,arry.length-1);
poll.invoke(sumTask);//同步执行,主线程阻塞在此处
long endTime = System.currentTimeMillis();
System.out.println(sumTask.join());
System.out.println("耗时:"+String.valueOf(endTime-time));
}
}
结果解析:
在每次累加的时候都sleep了1ms,以便于我们观察结果
1.在单线程下执行了大致5s
2.在ForkJoin下大致执行了1s
根据结论,符合分治法的任务通过ForkJoin可以大大提升性能
注:
我们去掉每次累加的1ms发现单线程居然比ForkJoin要快,这是因为多线程的执行时间过于短,造成了线程之间的上下文切换过于频繁,耗时主要在这个地方
2、异步用法+不要求返回值
下面是获取指定目录下的特定文件格式的文件(用异步fork/join框架实现)
package cn.enjoy.controller.thread.ForkJoin;
import com.sun.tools.javac.util.ArrayUtils;
import org.springframework.util.CollectionUtils;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
/**
* @author:wangle
* @description:获取指定目录下的某种文件格式的文件(含子目录)
* @version:V1.0
* @date:2020-03-21 20:13
**/
public class ForkJoinGetFile extends RecursiveAction {
private File path;
public ForkJoinGetFile(File path){
this.path=path;
}
@Override
protected void compute(){
List<ForkJoinGetFile> forkJoinGetFileList = new ArrayList<>();
File[] files = path.listFiles();
if(null != files && files.length!=0){
for(File file:files){
if(file.isDirectory()){
forkJoinGetFileList.add(new ForkJoinGetFile(file));
}else {
//遇到文件,检查文件类型
if(file.getAbsolutePath().endsWith("png")){
System.out.println("文件:"+file.getAbsolutePath());
}
}
}
if(!CollectionUtils.isEmpty(forkJoinGetFileList)){
for(ForkJoinGetFile forkJoinGetFile : invokeAll(forkJoinGetFileList)){
forkJoinGetFile.join();
}
}
}
}
public static void main(String[] args){
ForkJoinPool poll = new ForkJoinPool();
ForkJoinGetFile task = new ForkJoinGetFile(new File("/Users/wangle/Desktop"));
//异步执行,不阻塞主线程
poll.execute(task);
System.out.println("main thread run");
task.join();
}
}
执行结果:
可以看到,打印出了我的桌面上的所有的jpg文件,并且未阻塞主线程,如果将execute换成invoke,则主线程会阻塞到任务结束之后,在程序中的显示就是main thread run会在任务结束后再打印出来,有兴趣的小伙伴可以自己capy代码到本地试试。