内容概要

RecursiveTask的优点在于能够将复杂任务递归分解为更小的子任务，从而提高处理效率，通过ForkJoinPool执行，RecursiveTask能充分利用多核处理器资源，实现任务的并行化处理，大大加快了计算速度，此外，它还简化了并行编程的复杂性，使开发者能够更专注于业务逻辑的实现。

官方文档：docx.iamqiang.com/jdk11/api/j...

核心概念

RecursiveTask 主要实现递归任务，它在并发编程中经常被使用，特别是在处理那些可以分解为更小的子问题的算法时，RecursiveTask 的主要用途是解决以下问题：

递归并行计算 ：当一个任务可以分解为几个子任务，并且这些子任务可以并行执行时，RecursiveTask 非常有用，通过将问题分解为更小的子问题，并利用多线程并行处理这些子问题，可以显著提高算法的执行效率。
数据分片 ：当处理大规模数据集时，可以将数据集分成较小的片段（或"分片"），每个片段可以在单独的线程上处理，RecursiveTask 可以用于定义如何将一个大的数据集分解为小的分片，并如何处理这些分片。
优化递归 ：在传统的递归算法中，如果递归深度太大，可能会导致栈溢出，使用 RecursiveTask 可以将一个大问题分解为多个小问题，从而减少了单个递归调用的深度，降低了栈溢出的风险。
简化并发编程 ：RecursiveTask 提供了一种结构化的方式来编写并发代码，使得代码更容易理解和维护，它还提供了许多有用的工具和机制，如任务拆分、依赖管理、结果合并等，使得并发编程更加便捷。

使用 RecursiveTask 尤其要注意子任务之间不能有共享状态或相互依赖，而且子任务可以独立地完成，如果任务不是可并行化的，使用 RecursiveTask 可能会导致错误的结果或不可预期的行为。

代码案例

RecursiveTask 是 ForkJoinTask 的一个子类，通常用于表示可以并行执行的任务，特别是那些可以递归拆分成更小的子任务的任务，下面是使用 RecursiveTask 的代码案例，该代码计算一个整数数组的元素之和，如下代码：

java 复制代码

import java.util.concurrent.ForkJoinPool;  
import java.util.concurrent.RecursiveTask;  
  
public class SumArrayTask extends RecursiveTask<Integer> {  
  
    private static final int THRESHOLD = 10; // 阈值，当数组长度小于此值时，不再拆分任务  
    private final int[] array;  
    private final int start;  
    private final int end;  
  
    public SumArrayTask(int[] array) {  
        this(array, 0, array.length);  
    }  
  
    private SumArrayTask(int[] array, int start, int end) {  
        this.array = array;  
        this.start = start;  
        this.end = end;  
    }  
  
    @Override  
    protected Integer compute() {  
        // 如果任务足够小，直接计算结果  
        if (end - start <= THRESHOLD) {  
            int sum = 0;  
            for (int i = start; i < end; i++) {  
                sum += array[i];  
            }  
            return sum;  
        } else {  
            // 拆分任务  
            int mid = start + (end - start) / 2;  
            SumArrayTask leftTask = new SumArrayTask(array, start, mid);  
            SumArrayTask rightTask = new SumArrayTask(array, mid, end);  
  
            // 递归执行任务并等待结果  
            invokeAll(leftTask, rightTask);  
            return leftTask.join() + rightTask.join();  
        }  
    }  
  
    public static void main(String[] args) {  
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20};  
  
        // 创建一个 ForkJoinPool  
        ForkJoinPool pool = new ForkJoinPool();  
  
        // 提交任务并获取结果  
        SumArrayTask task = new SumArrayTask(array);  
        int sum = pool.invoke(task);  
  
        // 输出结果  
        System.out.println("Sum of array elements: " + sum);  
  
        // 关闭 ForkJoinPool（通常不是必须的，因为它会在所有任务完成后自动关闭）  
        pool.shutdown();  
    }  
}

上面的代码定义了一个 SumArrayTask 类，它继承自 RecursiveTask，SumArrayTask 的任务是计算一个整数数组的子数组的元素之和，如果子数组的长度小于一个阈值（这里设置为 10），则直接计算结果；否则，任务会被拆分成两个更小的子任务，分别计算左半部分和右半部分的和，然后再将这两个和相加得到最终结果。

运行上面代码，会有如下输出结果：

c 复制代码

Sum of array elements: 210

核心API

RecursiveTask 是 ForkJoinTask 的一个子类，用于支持可以递归划分并且可能需要执行大量计算的任务，RecursiveTask 有一个显著的特点：它有返回值，这与其他基于 ForkJoinPool 的任务（如 RecursiveAction）不同，后者不返回结果。

以下是 RecursiveTask 中一些重要的方法及其含义：

RecursiveTask() ：构造方法，通常会通过覆盖此类的构造方法来初始化任务所需的任何状态。
compute() ：这是一个抽象方法，意味着当定义 RecursiveTask 时必须实现它，这个方法定义了任务的实际计算逻辑，通常，会在这个方法中决定任务是应该继续递归分解还是已经足够小，可以直接计算。
fork() ：这个方法是从 ForkJoinTask 继承来的，它用于在 ForkJoinPool 中异步执行当前任务，调用 fork() 会导致当前任务被安排到某个工作线程上，然后立即返回，允许调用者继续执行其他任务。
join() ：这也是从 ForkJoinTask 继承来的方法，它会阻塞当前线程，直到任务完成执行并返回结果，如果在一个任务中调用了另一个任务的 fork()，然后需要等待那个任务完成并获取其结果，就会使用 join()。
invoke() ：这也是 ForkJoinTask 的一个方法，但通常不直接在 RecursiveTask 中使用，它主要用于非 ForkJoinPool 线程中启动任务，它会简单地调用 fork()（如果当前线程是 ForkJoinPool 的一部分）或直接调用 compute()（如果不是）。
isCompletedAbnormally() ：检查任务是否因为抛出异常而异常完成。
isCancelled() ：检查任务是否已经被取消。
getRawResult() ：获取任务的结果，但不等待任务完成，如果任务尚未完成，这可能会返回一个不完整或无效的结果。
setRawResult(V) ：设置任务的结果，这通常不是由应用程序代码直接调用的，而是在 compute() 方法内部，当任务完成其计算时使用。
exec() ：这是一个受保护的方法，通常在 ForkJoinTask 子类内部使用，用于实际执行任务，在大多数情况下，不需要直接覆盖或调用这个方法，除非正在进行一些非常特殊的扩展。

在使用RecursiveTask 时，通常需要重点关注 compute() 方法以及可能涉及任务分解和组合的逻辑，fork() 和 join() 是在这些逻辑中最常用的方法，而其他方法更多地用于查询任务的状态或进行更高级的控制。

核心总结

RecursiveTask 是 Java 中专为支持可分解的并行任务设计，它的优点在于能轻松将大问题拆分成小问题，通过 ForkJoinPool 高效利用多核处理器，简化并行编程，它的缺点也很明显，比如递归分解可能引入额外开销，且不适合有状态或相互依赖的任务，在使用时，确保任务无状态且可独立执行，合理设置阈值以避免过度分解，同时考虑任务的平衡性以减少等待时间，总之RecursiveTask的优势就是处理可递归划分且无依赖的计算密集型任务。

END!

【揭秘】RecursiveTask全面解析

内容概要

核心概念

代码案例

核心API

核心总结