Most visited

Recently visited

Results for

Added in API level 21

Summary: Ctors | Methods | Protected Methods | Inherited Methods | [Expand All]

RecursiveAction

public abstract class RecursiveAction
extends ForkJoinTask<Void>

java.lang.Object
	java.util.concurrent.ForkJoinTask<java.lang.Void>
		java.util.concurrent.RecursiveAction

递归无结果ForkJoinTask 。这个类建立约定来参数化无结果行为Void ForkJoinTask s。因为null的类型是唯一有效的值Void ，如方法join总是返回null完成时。

样本使用。 这是一个简单但完整的ForkJoin排序， long[]给定的long[]数组进行排序：

 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++];
   }
 }

You could then sort anArray by creating new SortTask(anArray) and invoking it in a ForkJoinPool. As a more concrete simple example, the following task increments each element of an array:

 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的动态阈值，但是通过直接对未执行任务执行叶子动作而不是进一步细分来平衡潜在的过量分割。

 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;
   }
 }

摘要(Summary)

Public constructors
`RecursiveAction()`

公共方法(Public methods)
`final Void`	`getRawResult()` 总是返回 `null` 。

Protected methods
`abstract void`	`compute()` 此任务执行的主要计算。
`final boolean`	`exec()` 为RecursiveActions实现执行约定。
`final void`	`setRawResult(Void mustBeNull)` 需要空值完成值。

继承方法(Inherited methods)

From class java.util.concurrent.ForkJoinTask

`static <T> ForkJoinTask<T>`	`adapt(Runnable runnable, T result)` 返回一个新的 `ForkJoinTask` ，该 `run`执行给定的 `Runnable`的 `run`方法作为其操作，并将给定的结果返回到 `join()` 。
`static ForkJoinTask<?>`	`adapt(Runnable runnable)` 返回一个新的 `ForkJoinTask` ，它执行给定 `Runnable`的 `run`方法作为其操作，并在 `join()`返回空结果。
`static <T> ForkJoinTask<T>`	`adapt(Callable<? extends T> callable)` 返回一个新的 `ForkJoinTask` ，它执行给定 `Callable`的 `call`方法作为其操作，并在 `join()`返回结果，将检测到的任何异常转换为 `RuntimeException` 。
`boolean`	`cancel(boolean mayInterruptIfRunning)` 试图取消执行此任务。
`final boolean`	`compareAndSetForkJoinTaskTag(short expect, short update)` 原子上有条件地设置此任务的标记值。
`void`	`complete(Void value)` 完成此任务，如果尚未中止或取消，则返回给定值，作为后续调用 `join`和相关操作的结果。
`void`	`completeExceptionally(Throwable ex)` 异常完成此任务，如果尚未中止或取消，则使其在 `join`及相关操作中抛出给定异常。
`abstract boolean`	`exec()` 立即执行此任务的基本操作，并返回true，如果从此方法返回后，此任务保证已正常完成。
`final ForkJoinTask<Void>`	`fork()` 安排在池异步执行这一任务，当前任务运行在（如果适用），或使用 `commonPool()`如果不是 `inForkJoinPool()` 。
`final Void`	`get(long timeout, TimeUnit unit)` 如果需要，最多等待计算完成的给定时间，然后检索其结果（如果可用）。
`final Void`	`get()` 如果需要，等待计算完成，然后检索其结果。
`final Throwable`	`getException()` 返回基本计算抛出的异常，或者 `CancellationException`如果取消）或 `null`如果没有）或方法尚未完成。
`final short`	`getForkJoinTaskTag()` 返回此任务的标签。
`static ForkJoinPool`	`getPool()` 返回宿主当前线程的池，如果当前线程在任何ForkJoinPool之外执行，则返回 `null` 。
`static int`	`getQueuedTaskCount()` 返回当前工作线程已分叉但尚未执行的任务数的估计值。
`abstract Void`	`getRawResult()` 返回 `join()`返回的结果，即使此任务异常完成，或 `null`如果此任务未知完成。
`static int`	`getSurplusQueuedTaskCount()` 返回当前工作线程持有多少本地排队任务的估计值，而不是其他可能窃取它们的工作线程的值，如果此线程未在ForkJoinPool中运行，则返回零。
`static void`	`helpQuiesce()` 可能会执行任务，直到托管当前任务 is quiescent的池为止。
`static boolean`	`inForkJoinPool()` 返回 `true`如果当前线程是 `ForkJoinWorkerThread`执行作为ForkJoinPool计算。
`final Void`	`invoke()` 开始执行此任务，并等待其完成（如有必要）并返回其结果，或者如果基础计算执行此操作，则抛出（未选中） `RuntimeException`或 `Error` 。
`static void`	`invokeAll(ForkJoinTask...<?> tasks)` `isDone`给定的任务，当 `isDone`对每个任务持有或遇到（未经检查）的异常时返回，在这种情况下重新排除异常。
`static void`	`invokeAll(ForkJoinTask<?> t1, ForkJoinTask<?> t2)` `isDone`给定的任务，当每个任务持有 `isDone`或遇到（未检查）的异常时返回，在这种情况下，异常将被重新抛出。
`static <T extends ForkJoinTask<?>> Collection<T>`	`invokeAll(Collection<T> tasks)` `isDone`指定集合中的所有任务，当每个任务持有 `isDone`或遇到（未检查）异常时返回，在这种情况下，将重新抛出异常。
`final boolean`	`isCancelled()` 如果此任务在正常完成之前取消，则返回 `true` 。
`final boolean`	`isCompletedAbnormally()` 如果此任务引发异常或被取消，则返回 `true` 。
`final boolean`	`isCompletedNormally()` 如果此任务完成而没有抛出异常并且未取消，则返回 `true` 。
`final boolean`	`isDone()` 如果此任务完成，则返回 `true` 。
`final Void`	`join()` 返回 `is done`时的计算结果。
`static ForkJoinTask<?>`	`peekNextLocalTask()` 返回但不排除或执行由当前线程排队但尚未执行的任务（如果立即可用）。
`static ForkJoinTask<?>`	`pollNextLocalTask()` 如果当前线程正在ForkJoinPool中运行，那么取消调度并返回（不执行）下一个由当前线程排队但尚未执行的任务。
`static ForkJoinTask<?>`	`pollTask()` 如果当前线程正在ForkJoinPool中运行，则取消调度并返回（不执行）由当前线程排队但尚未执行的下一个任务（如果有）或者不可用时由其他线程分叉的任务，如果可供使用的话。
`final void`	`quietlyComplete()` 通常无需设置值即可完成此任务。
`final void`	`quietlyInvoke()` 开始执行此任务并在必要时等待完成，而不返回结果或抛出异常。
`final void`	`quietlyJoin()` 加入此任务，但不返回结果或抛出异常。
`void`	`reinitialize()` 重置此任务的内部簿记状态，允许随后的 `fork` 。
`final short`	`setForkJoinTaskTag(short newValue)` 以原子方式设置此任务的标记值并返回旧值。
`abstract void`	`setRawResult(Void value)` 因此强制返回给定的值。
`boolean`	`tryUnfork()` 试图排除这个任务的执行。

From class java.lang.Object

From interface java.util.concurrent.Future

Public constructors