Java 并发之 ForkJoinPool

1,213 阅读4分钟

前言

Fork/Join的使用场景

  • Java提供Fork/Join框架用于并行执行任务,它的思想就是讲一个大任务分割成若干小任务,最终汇总每个小任务的结果得到这个大任务的结果。
  • 主要有两步:
    • 第一、任务切分。
    • 第二、结果合并。

其大致模型和架构

它的模型大致是这样的:

  • 线程池中的每个线程都有自己的工作队列(PS:这一点和ThreadPoolExecutor不同,ThreadPoolExecutor是所有线程公用一个工作队列,所有线程都从这个工作队列中取任务),当自己队列中的任务都完成以后,会从其它线程的工作队列中偷一个任务执行,这样可以充分利用资源。
  • 工作窃取(work-stealing)
    • 工作窃取(work-stealing)算法是指某个线程从其他队列里窃取任务来执行。工作窃取的运行流程图如下:

工作窃取.png

那么为什么需要使用工作窃取算法呢?

  • 假如我们需要做一个比较大的任务,我们可以把这个任务分割为若干互不依赖的子任务,为了减少线程间的竞争,于是把这些子任务分别放到不同的队列里,并为每个队列创建一个单独的线程来执行队列里的任务,线程和队列一一对应,比如A线程负责处理A队列里的任务。但是有的线程会先把自己队列里的任务干完,而其他线程对应的队列里还有任务等待处理。干完活的线程与其等着,不如去帮其他线程干活,于是它就去其他线程的队列里窃取一个任务来执行。而在这时它们会访问同一个队列,所以为了减少窃取任务线程和被窃取任务线程之间的竞争,通常会使用双端队列,被窃取任务线程永远从双端队列的头部拿任务执行,而窃取任务的线程永远从双端队列的尾部拿任务执行。

  • 工作窃取算法的优点是充分利用线程进行并行计算,并减少了线程间的竞争,其缺点是在某些情况下还是存在竞争,比如双端队列里只有一个任务时。并且消耗了更多的系统资源,比如创建多个线程和多个双端队列。

其架构

image.png

说明任务可以通过submit方法提交,任务可以是Runnable也可以是Callable。
但是,用submit提交任务无法触发工作窃取算法!!!!

阅读其jdk源码

构造方法

image.png


image.png

image.png

既然submit不能触发工作窃取算法,那怎么提交任务

  • 常用抽象类ForkJoinTask<V>的子类RecursiveActionRecursiveTask
  • RecursiveAction没有返回值
  • RecursiveTask有返回值。 jdk源码如下

image.png

image.png

样例

下面是甲骨文公司提供的ForkJoin的动画

求数组中的最大值,数组大小是14

  • 关键代码

image.png 动画3.gif

下面是烂大街的累加任务的任务分解

public class ForkJoinTest {
    public static void main(String[] args) {
        int result;
        CalculateTask calculateTask = new CalculateTask(1,100);
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        result = forkJoinPool.invoke(calculateTask);
        forkJoinPool.shutdown();
        System.out.println(result);

    }
}
class CalculateTask extends RecursiveTask<Integer>{
    private static final int LIMIT = 4;//数值间的间隔最大值,将任务拆成间隔小于等于4的求和任务
    private final int startIndex;
    private final int endIndex;

    public CalculateTask(int startIndex, int endIndex) {//构造方法
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

    @Override
    protected Integer compute() {
        int result;
        int gaps = endIndex-startIndex;
        boolean flag = gaps <= LIMIT ;
        /**
         * 1加到5为一个任务
         * 5加到9为一个任务
         * 。。。。
         * 差不多像这样
        **/
        if (flag){
            System.out.println(Thread.currentThread().getName());

            result = IntStream.rangeClosed(startIndex,endIndex).reduce(0,Integer::sum);
            //间隔小于等于4,累加起来
            

        }else {
            int middleIndex = (startIndex+endIndex) / 2;//分治

            CalculateTask leftTask = new CalculateTask(startIndex,middleIndex);
            //将其拆分直到间隔小于等于4
            //一个任务就变成了两个任务
            CalculateTask rightTask = new CalculateTask(middleIndex+1,endIndex);

            invokeAll(leftTask,rightTask);//激活任务

            int leftTaskResult = leftTask.join();//获取任务的结果
            int rightTaskResult = rightTask.join();

            result = leftTaskResult+rightTaskResult;

        }
        return result;//返回最终结果
    }
}

小结

使用注意点

  • CPU密集型任务适合ForkJoinPool
  • I/O密集型任务不适合ForkJoinPool
  • ForkJoinPool不一定比单线程要好,因为里面涉及到线程切换和创建。有可能会降低性能。所以在多线程开发时要和单线程进行比较,以免负优化。