Java中的Java .util.concurrent.RecursiveTask 类与示例

RecursiveTask是一个抽象类，封装了一个返回结果的任务。它是ForkJoinTask的子类。 RecursiveTask 类被扩展以创建具有特定返回类型的任务。代表任务计算部分的代码保存在 RecursiveTask 的compute()方法中。

RecursiveTask类主要用于并行编程的上下文中。可以将任务划分为独立的子任务，并且可以从子任务的结果中获得任务的最终结果，使用 RecursiveTask 可以更有效地实现。例如，在一个大数组中搜索一个元素。

类层次结构

java.lang.Object
↳ java.util.concurrent.ForkJoinTask
  ↳ java.util.concurrent.RecursiveTask

构造函数

RecursiveTask() – 创建一个具有默认设置的 RecursiveTask 对象。
```
public RecursiveTask()
```

方法

compute() – 定义任务的方法。
```
protected abstract void compute()
```
exec() - 此方法实现了执行任务所需的基本规则。
```
protected final boolean exec()
```
getRawResult() - 该函数返回任务完成后获得的值，即使任务异常完成。如果任务尚未完成，则返回 null。
```
public final Void getRawResult()
```
setRawResult() – 该函数将任务的返回值设置为参数中传递的值。
```
protected final void setRawResult(Void mustBeNull)
```

演示 RecursiveTask 的示例

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
  
public class RecursiveTaskDemo {
    public static void main(String[] args)
    {
        ForkJoinPool fjp = new ForkJoinPool();
  
        double[] nums = new double[5000];
        for (int i = 0; i < nums.length; i++) {
            nums[i] = (double)(((i % 2) == 0) ? i : -1);
        }
        Sum task = new Sum(nums, 0, nums.length);
        double summation = fjp.invoke(task);
        System.out.println("Summation " + summation);
    }
}
  
class Sum extends RecursiveTask {
    final int seqThreshold = 500;
    double[] data;
    int start, end;
  
    Sum(double[] data, int start, int end)
    {
        this.data = data;
        this.start = start;
        this.end = end;
    }
  
    @Override
    protected Double compute()
    {
        double sum = 0;
        if ((end - start) < seqThreshold) {
            for (int i = start; i < end; i++)
                sum += data[i];
        }
        else {
            int middle = (start + end) / 2;
  
            Sum subtaskA = new Sum(data, start, middle);
            Sum subtaskB = new Sum(data, middle, end);
  
            subtaskA.fork();
            subtaskB.fork();
  
            sum += subtaskA.join() + subtaskB.join();
        }
        return sum;
    }
}

输出：

Summation 6245000.0

参考： https: Java/util/concurrent/RecursiveTask.html