Java Java.util.concurrent.RecursiveAction用法及代码示例

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

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

类层次结构

java.lang.Object
↳ java.util.concurrent.ForkJoinTask<Void>
  ↳ java.util.concurrent.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://docs.oracle.com/javase/8/docs/api/java/util/concurrent/RecursiveAction.html

相关用法

注：本文由纯净天空筛选整理自CharchitKapoor大神的英文原创作品 Java.util.concurrent.RecursiveAction class in Java with Examples。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。