2.1 线程的并发工具类-fork/join

一、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代码到本地试试。