public abstract class RecursiveAction extends ForkJoinTask<Void>
ForkJoinTask 。
该类确定了将无结果动作Void ForkJoinTask ，如Void ForkJoinTask 。
因为null类型是唯一有效的值Void ，如方法join总是返回null完成时。
示例用法 这是一个简单但完整的ForkJoin排序，排序给定的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++]; } }
然后，您可以进行排序anArray创建new SortTask(anArray) ，并在ForkJoinPool调用它。
作为一个更具体的简单示例，以下任务会增加数组的每个元素：
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)); } } }
以下示例说明了可能导致更好性能的一些改进和习语：递归方法不需要完全递归，只要它们保持基本的划分和征服方法。 这是一个通过将只有重复划分的右手区域除以2的方式来对双阵列的每个元素的平方进行求和的类，并用next引用链来跟踪它们。 它使用基于方法getSurplusQueuedTaskCount的动态阈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; } }
| Constructor and Description |
|---|
RecursiveAction() |
| Modifier and Type | Method and Description |
|---|---|
protected abstract void |
compute()
这个任务执行的主要计算。
|
protected boolean |
exec()
执行递归法的执行约定。
|
Void |
getRawResult()
总是返回
null 。
|
protected void |
setRawResult(Void mustBeNull)
需要空完成值。
|
adapt, adapt, adapt, cancel, compareAndSetForkJoinTaskTag, complete, completeExceptionally, fork, get, get, getException, getForkJoinTaskTag, getPool, getQueuedTaskCount, getSurplusQueuedTaskCount, helpQuiesce, inForkJoinPool, invoke, invokeAll, invokeAll, invokeAll, isCancelled, isCompletedAbnormally, isCompletedNormally, isDone, join, peekNextLocalTask, pollNextLocalTask, pollTask, quietlyComplete, quietlyInvoke, quietlyJoin, reinitialize, setForkJoinTaskTag, tryUnforkprotected abstract void compute()
public final Void getRawResult()
null 。
getRawResult在类别
ForkJoinTask<Void>
null总是
protected final void setRawResult(Void mustBeNull)
setRawResult在类别
ForkJoinTask<Void>
mustBeNull - 值
protected final boolean exec()
exec在类别
ForkJoinTask<Void>
true如果此任务已知已正常完成