diff options
Diffstat (limited to 'src/forkjoin/scala/concurrent/forkjoin/RecursiveAction.java')
-rw-r--r-- | src/forkjoin/scala/concurrent/forkjoin/RecursiveAction.java | 164 |
1 files changed, 0 insertions, 164 deletions
diff --git a/src/forkjoin/scala/concurrent/forkjoin/RecursiveAction.java b/src/forkjoin/scala/concurrent/forkjoin/RecursiveAction.java deleted file mode 100644 index 1e7cdd952d..0000000000 --- a/src/forkjoin/scala/concurrent/forkjoin/RecursiveAction.java +++ /dev/null @@ -1,164 +0,0 @@ -/* - * Written by Doug Lea with assistance from members of JCP JSR-166 - * Expert Group and released to the public domain, as explained at - * http://creativecommons.org/publicdomain/zero/1.0/ - */ - -package scala.concurrent.forkjoin; - -/** - * A recursive resultless {@link ForkJoinTask}. This class - * establishes conventions to parameterize resultless actions as - * {@code Void} {@code ForkJoinTask}s. Because {@code null} is the - * only valid value of type {@code Void}, methods such as {@code join} - * always return {@code null} upon completion. - * - * <p><b>Sample Usages.</b> Here is a simple but complete ForkJoin - * sort that sorts a given {@code long[]} array: - * - * <pre> {@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: - * final static 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++]; - * } - * }}</pre> - * - * You could then sort {@code anArray} by creating {@code new - * SortTask(anArray)} and invoking it in a ForkJoinPool. As a more - * concrete simple example, the following task increments each element - * of an array: - * <pre> {@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)); - * } - * } - * }}</pre> - * - * <p>The following example illustrates some refinements and idioms - * that may lead to better performance: RecursiveActions need not be - * fully recursive, so long as they maintain the basic - * divide-and-conquer approach. Here is a class that sums the squares - * of each element of a double array, by subdividing out only the - * right-hand-sides of repeated divisions by two, and keeping track of - * them with a chain of {@code next} references. It uses a dynamic - * threshold based on method {@code getSurplusQueuedTaskCount}, but - * counterbalances potential excess partitioning by directly - * performing leaf actions on unstolen tasks rather than further - * subdividing. - * - * <pre> {@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; - * } - * }}</pre> - * - * @since 1.7 - * @author Doug Lea - */ -public abstract class RecursiveAction extends ForkJoinTask<Void> { - private static final long serialVersionUID = 5232453952276485070L; - - /** - * The main computation performed by this task. - */ - protected abstract void compute(); - - /** - * Always returns {@code null}. - * - * @return {@code null} always - */ - public final Void getRawResult() { return null; } - - /** - * Requires null completion value. - */ - protected final void setRawResult(Void mustBeNull) { } - - /** - * Implements execution conventions for RecursiveActions. - */ - protected final boolean exec() { - compute(); - return true; - } - -} |