RecursiveAction 类

定义

[Android.Runtime.Register("java/util/concurrent/RecursiveAction", DoNotGenerateAcw=true)]
public abstract class RecursiveAction : Java.Util.Concurrent.ForkJoinTask

[<Android.Runtime.Register("java/util/concurrent/RecursiveAction", DoNotGenerateAcw=true)>]
type RecursiveAction = class
    inherit ForkJoinTask

继承

Object

Object

ForkJoinTask

RecursiveAction

属性

RegisterAttribute

注解

递归的结果。ForkJoinTask 此类建立将无结果操作参数化为 VoidForkJoinTasks 的约定。 由于 null 是类型 Void的唯一有效值，因此方法（如 join 在完成时始终返回 null ）。

<b>示例用法。</b> 下面是对给定 long[] 数组进行排序的简单但完整的 ForkJoin 排序：

{@code
            static class SortTask extends RecursiveAction {
              final long[] array; final int lo, hi;
              SortTask(long[] array, int lo, int hi) {
                this.array = array; this.lo = lo; this.hi = hi;
              }
              SortTask(long[] array) { this(array, 0, array.length); }
              protected void compute() {
                if (hi - lo < THRESHOLD)
                  sortSequentially(lo, hi);
                else {
                  int mid = (lo + hi) >>> 1;
                  invokeAll(new SortTask(array, lo, mid),
                            new SortTask(array, mid, hi));
                  merge(lo, mid, hi);
                }
              }
              // implementation details follow:
              static final int THRESHOLD = 1000;
              void sortSequentially(int lo, int hi) {
                Arrays.sort(array, lo, hi);
              }
              void merge(int lo, int mid, int hi) {
                long[] buf = Arrays.copyOfRange(array, lo, mid);
                for (int i = 0, j = lo, k = mid; i < buf.length; j++)
                  array[j] = (k == hi || buf[i] < array[k]) ?
                    buf[i++] : array[k++];
              }
            }}

然后，可以通过在 ForkJoinPool 中创建new SortTask(anArray)和调用它进行排序anArray。 作为一个更具体的简单示例，以下任务递增数组的每个元素：

{@code
            class IncrementTask extends RecursiveAction {
              final long[] array; final int lo, hi;
              IncrementTask(long[] array, int lo, int hi) {
                this.array = array; this.lo = lo; this.hi = hi;
              }
              protected void compute() {
                if (hi - lo < THRESHOLD) {
                  for (int i = lo; i < hi; ++i)
                    array[i]++;
                }
                else {
                  int mid = (lo + hi) >>> 1;
                  invokeAll(new IncrementTask(array, lo, mid),
                            new IncrementTask(array, mid, hi));
                }
              }
            }}

以下示例演示了一些可能导致性能更佳的精简和习惯：只要递归方法保持基本划分和征服方法，RecursiveActions 就不需要完全递归。 下面是一个类，它通过将重复除法的右侧细分为两个，并使用引用链 next 跟踪它们，来对双数组的每个元素的平方求和。 它使用基于方法 getSurplusQueuedTaskCount的动态阈值，但通过直接对未被盗任务执行叶操作而不是进一步细分来抵消潜在的过度分区。

{@code
            double sumOfSquares(ForkJoinPool pool, double[] array) {
              int n = array.length;
              Applyer a = new Applyer(array, 0, n, null);
              pool.invoke(a);
              return a.result;
            }

            class Applyer extends RecursiveAction {
              final double[] array;
              final int lo, hi;
              double result;
              Applyer next; // keeps track of right-hand-side tasks
              Applyer(double[] array, int lo, int hi, Applyer next) {
                this.array = array; this.lo = lo; this.hi = hi;
                this.next = next;
              }

              double atLeaf(int l, int h) {
                double sum = 0;
                for (int i = l; i < h; ++i) // perform leftmost base step
                  sum += array[i] * array[i];
                return sum;
              }

              protected void compute() {
                int l = lo;
                int h = hi;
                Applyer right = null;
                while (h - l > 1 && getSurplusQueuedTaskCount() <= 3) {
                  int mid = (l + h) >>> 1;
                  right = new Applyer(array, mid, h, right);
                  right.fork();
                  h = mid;
                }
                double sum = atLeaf(l, h);
                while (right != null) {
                  if (right.tryUnfork()) // directly calculate if not stolen
                    sum += right.atLeaf(right.lo, right.hi);
                  else {
                    right.join();
                    sum += right.result;
                  }
                  right = right.next;
                }
                result = sum;
              }
            }}

已在 1.7 中添加。

Java文档java.util.concurrent.RecursiveAction。

本页的某些部分是根据 创建和共享的工作进行的修改，并根据 许可证中所述的条款使用。