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

RecursiveAction是一个抽象类，封装了一个不返回结果的任务。它是ForkJoinTask的子类，它是一个抽象类，表示可以在多核系统中的单独核心上执行的任务。扩展 RecursiveAction 类以创建具有void返回类型的任务。代表任务计算部分的代码保存在 RecursiveAction 的compute()方法中。

RecursiveAction 用于可拆分和并行执行的任务。这些任务不应返回任何值。例如，可以使用 RecursiveAction 轻松实现对大型数组的排序，将数组划分为可管理的小块，每个部分在单独的核心上进行排序。

类层次结构

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

RecursiveAction 的构造函数：

RecursiveAction ：使用默认设置创建一个 RecursiveAction 对象。
句法：
```
public RecursiveAction()
```

方法

compute() – 它是由任务执行计算的方法。
句法：
```
protected abstract void compute()
```
exec() - 此方法实现了执行 RecursiveAction 任务所需的基本规则。
句法：
```
protected final boolean exec()
```
getRawResult() – 该函数返回任务完成状态。它总是返回 null。
句法：
```
public final Void getRawResult()
```
setRawResult() – 该函数将任务完成状态设置为参数中传递的值。
句法：
```
protected final void setRawResult(Void mustBeNull)
```

示例：演示 RecursiveAction 类

// Java program to demonstrate RecursiveAction Class
  
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
  
public class ForkJoinDemo {
    public static void main(String[] args)
    {
        // Create a pool of threads.
        ForkJoinPool fjp = new ForkJoinPool();
        double[] nums = new double[100000];
  
        // Give nums some values
        for (int i = 0; i < nums.length; i++) {
            nums[i] = (double)i;
        }
        System.out.println("A portion of the original sequence");
        for (int i = 0; i < 9; i++) {
            System.out.print(nums[i] + " ");
        }
        System.out.println();
        SqrtTransform task
            = new SqrtTransform(nums, 0, nums.length);
  
        // Start the task
        fjp.invoke(task);
        System.out.println("A portion of the transformed sequence"
                           + " (to four decimal places): ");
        for (int i = 0; i < 9; i++) {
            System.out.printf("%.4f ", nums[i]);
        }
        System.out.println();
    }
}
  
// A task that transforms the elements into their square roots
class SqrtTransform extends RecursiveAction {
    final int seqThreshold = 1000;
  
    double[] data;
  
    // Determines what part of data to process
    int start, end;
  
    SqrtTransform(double[] data, int start, int end)
    {
        this.data = data;
        this.start = start;
        this.end = end;
    }
  
    // The method where parallel computation will occur
    @Override
    protected void compute()
    {
        // If the number of elements are less
        // than the sequential threshold
        if ((end - start) < seqThreshold) {
            for (int i = start; i < end; i++) {
                data[i] = Math.sqrt(data[i]);
            }
        }
        else {
            // Otherwise, continue to break the data into smaller pieces
            // Find the midpoint
            int middle = (start + end) / 2;
  
            // Invoke new tasks, using the subdivided tasks.
            invokeAll(new SqrtTransform(data, start, middle),
                      new SqrtTransform(data, middle, end));
        }
    }
}

输出：

A portion of the original sequence
0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 
A portion of the transformed sequence (to four decimal places): 
0.0000 1.0000 1.4142 1.7321 2.0000 2.2361 2.4495 2.6458 2.8284

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