【Java并发编程线程池】 ForkJoinPool 线程池是什么 怎么工作的 和传统的ThreadPoolExecutor比较

Java 中的 ForkJoinPool 线程池是什么 怎么工作的

Java 中的 ForkJoinPool 线程池是什么 怎么工作的

相比较于传统的线程池，ForkJoinPool 线程池更适合处理大量的计算密集型任务，它的核心思想是将一个大任务拆分成多个小任务，然后将这些小任务分配给多个线程去执行，最后将这些小任务的结果合并起来，得到最终的结果。

工作窃取

值得注意的，ForkJoinPool中的每个线程都有自己的任务队列，当线程任务队列空了或者当前线程空闲，则会去别的线程的任务队列获取待执行任务，这个过程是工作窃取。

怎么工作的

（一）：传统线程池

Java中传统线程池（ThreadPoolExecutor）的工作流程的描述：

以 new ThreadPoolExecutor(2, 4, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10)) 为例，线程池的工作流程如下：

代码用例：

public static void main1(String[] args) {
    final var poolExecutor = new ThreadPoolExecutor(
            2, // 核心线程数
            4, // 最大线程数
            60,// 线程空闲时间
            TimeUnit.SECONDS, // 时间单位
            new ArrayBlockingQueue<>(10), // 任务队列
            new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
    );
    // 定义一个Runnable
    MyRunnable runnable = new MyRunnable();
    // 提交任务
    for (int i = 0; i < 10; i++) {
        poolExecutor.submit(runnable);
    }
}

static class MyRunnable implements Runnable {
    @SneakyThrows
    @Override
    public void run() {
        Thread.sleep(1000);
        System.out.println("Hello, world!");
    }
}

1. 提交任务；
2. 线程池中的线程数量小于 corePoolSize（核心线程数）时，不管有没有空闲的线程，都会创建一个新的线程来执行任务；
3. 线程池中的线程数量等于 corePoolSize 时，若没有空闲线程，则任务会被放入任务队列中，等待线程池中的线程调度执行；
4. 核心线程数已满 且 任务队列已满时，线程数量小于 maximumPoolSize（最大线程数）时，会创建新的线程来执行任务；
5. 最后若是核心线程数、任务队列、最大线程数都满了，会根据拒绝策略来处理新任务。

图解：

（二）：ForkJoinPool 线程池

ForkJoinPool工作流程的描述：

以new ForkJoinPool(4) 和 普通的任务 为例，ForkJoinPool的工作流程如下：

代码用例：

public static void main(String[] args) {
    final var forkJoinPool = new ForkJoinPool(4);// 这个参数 “4” 的作用指定线程池的线程数量
    // 定义一个Runnable
    MyRunnable runnable = new MyRunnable();
    // 提交任务
    for (int i = 0; i < 10; i++) {
        forkJoinPool.submit(runnable);
    }
}

1. 提交任务；（初次执行时，会做一些初始化工作，如创建任务队列的数组）
2. 线程数量小于指定的线程数量时，会创建新的线程来执行任务，且每个线程都有自己的任务队列，区分于传统线程池只有一个任务队列，ForkJoinPool的线程池里的每个线程都有自己的任务队列；
3. 每个线程从自己的任务队列中取出任务执行；
4. 每个任务执行完毕后，且自己的任务队列为空时，会从其他线程的任务队列中偷取任务执行，这里被称作为“工作窃取”；

图解：

怎么体现将大任务拆分成小任务

在刚刚的代码用例中，我们提交了10个任务，但是我们的任务是一个普通的任务，没有体现将大任务拆分成小任务，下面我们换一个任务，体现将大任务拆分成小任务。

任务要求

要求计算 1 ～ 100w 的阶和，就是 "1+2+3+...+100w".

任务拆分方案：

我们可以将这个大任务拆分成多个小任务，将任务分配小到数的差值为10及以内时不再拆分，每个小任务计算区间的和，最后将这些小任务的结果合并起来，得到最终的结果。

如下

1:100w 的阶和 = 1w 的阶和 + 2w 的阶和 + 3w 的阶和 + ... + 10w 的阶和
2:10w 的阶和 = 1w 的阶和 + 2w 的阶和 + 3w 的阶和 + ... + 10w 的阶和
3:以此类推，直到区间的差值小于等于10时，不再拆分。
如100的阶和 = 1～10 的阶和 + 11～20 的阶和 + ... + 91～100 的阶和，其中 1～10的差值不大于10，不再拆分。

代码用例：

public static void main(String[] args) {
    // 任务要求：计算 1 ～ 100w 的阶和，就是 "1+2+3+...+100w".
    // 1. 创建一个 ForkJoinPool 对象
    ForkJoinPool forkJoinPool = new ForkJoinPool(4);
    // 2. 提交一个任务
    Integer result = forkJoinPool.invoke(new MyTask(1, 1000000));
    System.out.println("result = " + result);
}

private static class MyTask extends RecursiveTask<Integer> {
    private static final int THRESHOLD = 10;// 拆分最小任务的阈值
    private int begin;// 计算的区间的开始
    private int end;// 计算的区间的结束
    public MyTask(int begin, int end) {
        this.begin = begin;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if (end - begin <= THRESHOLD) {
            int sum = 0;
            for (int i = begin; i <= end; i++) {
                sum += i;
            }
            return sum;
        } else {
            int mid = (begin + end) / 2;
            MyTask left = new MyTask(begin, mid);
            MyTask right = new MyTask(mid + 1, end);
            left.fork();// 提交到任务队列
            right.fork();
            return left.join() + right.join();// join等待结果，线程会出现空闲，会去别的任务队列窃取任务执行
        }
    }
}

场景（常用于哪）

最常见、常用的场景中，其实就是在我们的Stream API中，我们使用了parallelStream()方法，底层就是使用了ForkJoinPool线程池。还有就是Java中新特性“虚拟线程”也是基于ForkJoinPool线程池实现的。