--- jsr166/src/jsr166y/ForkJoinTask.java 2009/08/02 11:54:31 1.27 +++ jsr166/src/jsr166y/ForkJoinTask.java 2009/08/04 00:36:45 1.33 @@ -12,6 +12,7 @@ import java.io.Serializable; import java.util.Collection; import java.util.Collections; import java.util.List; +import java.util.RandomAccess; import java.util.Map; import java.util.WeakHashMap; @@ -22,40 +23,42 @@ import java.util.WeakHashMap; * subtasks may be hosted by a small number of actual threads in a * ForkJoinPool, at the price of some usage limitations. * - *

A "main" ForkJoinTask begins execution when submitted to a - * {@link ForkJoinPool}. Once started, it will usually in turn start - * other subtasks. As indicated by the name of this class, many - * programs using ForkJoinTasks employ only methods {@code fork} and - * {@code join}, or derivatives such as {@code invokeAll}. However, - * this class also provides a number of other methods that can come - * into play in advanced usages, as well as extension mechanics that - * allow support of new forms of fork/join processing. + *

A "main" {@code ForkJoinTask} begins execution when submitted + * to a {@link ForkJoinPool}. Once started, it will usually in turn + * start other subtasks. As indicated by the name of this class, + * many programs using {@code ForkJoinTask} employ only methods + * {@link #fork} and {@link #join}, or derivatives such as {@link + * #invokeAll}. However, this class also provides a number of other + * methods that can come into play in advanced usages, as well as + * extension mechanics that allow support of new forms of fork/join + * processing. * - *

A ForkJoinTask is a lightweight form of {@link Future}. The - * efficiency of ForkJoinTasks stems from a set of restrictions (that - * are only partially statically enforceable) reflecting their - * intended use as computational tasks calculating pure functions or - * operating on purely isolated objects. The primary coordination - * mechanisms are {@link #fork}, that arranges asynchronous execution, - * and {@link #join}, that doesn't proceed until the task's result has - * been computed. Computations should avoid {@code synchronized} - * methods or blocks, and should minimize other blocking - * synchronization apart from joining other tasks or using - * synchronizers such as Phasers that are advertised to cooperate with - * fork/join scheduling. Tasks should also not perform blocking IO, - * and should ideally access variables that are completely independent - * of those accessed by other running tasks. Minor breaches of these - * restrictions, for example using shared output streams, may be - * tolerable in practice, but frequent use may result in poor - * performance, and the potential to indefinitely stall if the number - * of threads not waiting for IO or other external synchronization - * becomes exhausted. This usage restriction is in part enforced by - * not permitting checked exceptions such as {@code IOExceptions} - * to be thrown. However, computations may still encounter unchecked - * exceptions, that are rethrown to callers attempting join - * them. These exceptions may additionally include - * RejectedExecutionExceptions stemming from internal resource - * exhaustion such as failure to allocate internal task queues. + *

A {@code ForkJoinTask} is a lightweight form of {@link Future}. + * The efficiency of {@code ForkJoinTask}s stems from a set of + * restrictions (that are only partially statically enforceable) + * reflecting their intended use as computational tasks calculating + * pure functions or operating on purely isolated objects. The + * primary coordination mechanisms are {@link #fork}, that arranges + * asynchronous execution, and {@link #join}, that doesn't proceed + * until the task's result has been computed. Computations should + * avoid {@code synchronized} methods or blocks, and should minimize + * other blocking synchronization apart from joining other tasks or + * using synchronizers such as Phasers that are advertised to + * cooperate with fork/join scheduling. Tasks should also not perform + * blocking IO, and should ideally access variables that are + * completely independent of those accessed by other running + * tasks. Minor breaches of these restrictions, for example using + * shared output streams, may be tolerable in practice, but frequent + * use may result in poor performance, and the potential to + * indefinitely stall if the number of threads not waiting for IO or + * other external synchronization becomes exhausted. This usage + * restriction is in part enforced by not permitting checked + * exceptions such as {@code IOExceptions} to be thrown. However, + * computations may still encounter unchecked exceptions, that are + * rethrown to callers attempting to join them. These exceptions may + * additionally include RejectedExecutionExceptions stemming from + * internal resource exhaustion such as failure to allocate internal + * task queues. * *

The primary method for awaiting completion and extracting * results of a task is {@link #join}, but there are several variants: @@ -74,7 +77,7 @@ import java.util.WeakHashMap; * performs the most common form of parallel invocation: forking a set * of tasks and joining them all. * - *

The ForkJoinTask class is not usually directly subclassed. + *

The ForkJoinTask class is not usually directly subclassed. * Instead, you subclass one of the abstract classes that support a * particular style of fork/join processing, typically {@link * RecursiveAction} for computations that do not return results, or @@ -83,30 +86,30 @@ import java.util.WeakHashMap; * established in a constructor, and then defines a {@code compute} * method that somehow uses the control methods supplied by this base * class. While these methods have {@code public} access (to allow - * instances of different task subclasses to call each others + * instances of different task subclasses to call each other's * methods), some of them may only be called from within other * ForkJoinTasks (as may be determined using method {@link * #inForkJoinPool}). Attempts to invoke them in other contexts * result in exceptions or errors, possibly including * ClassCastException. * - *

Most base support methods are {@code final} because their - * implementations are intrinsically tied to the underlying - * lightweight task scheduling framework, and so cannot be overridden. - * Developers creating new basic styles of fork/join processing should - * minimally implement {@code protected} methods - * {@link #exec}, {@link #setRawResult}, and - * {@link #getRawResult}, while also introducing an abstract - * computational method that can be implemented in its subclasses, - * possibly relying on other {@code protected} methods provided - * by this class. + *

Most base support methods are {@code final}, to prevent + * overriding of implementations that are intrinsically tied to the + * underlying lightweight task scheduling framework. Developers + * creating new basic styles of fork/join processing should minimally + * implement {@code protected} methods {@link #exec}, {@link + * #setRawResult}, and {@link #getRawResult}, while also introducing + * an abstract computational method that can be implemented in its + * subclasses, possibly relying on other {@code protected} methods + * provided by this class. * *

ForkJoinTasks should perform relatively small amounts of - * computations, otherwise splitting into smaller tasks. As a very - * rough rule of thumb, a task should perform more than 100 and less - * than 10000 basic computational steps. If tasks are too big, then - * parallelism cannot improve throughput. If too small, then memory - * and internal task maintenance overhead may overwhelm processing. + * computation. Large tasks should be split into smaller subtasks, + * usually via recursive decomposition. As a very rough rule of thumb, + * a task should perform more than 100 and less than 10000 basic + * computational steps. If tasks are too big, then parallelism cannot + * improve throughput. If too small, then memory and internal task + * maintenance overhead may overwhelm processing. * *

This class provides {@code adapt} methods for {@link * java.lang.Runnable} and {@link java.util.concurrent.Callable}, that @@ -114,11 +117,10 @@ import java.util.WeakHashMap; * kinds of tasks. When all tasks are of this form, consider using a * pool in {@link ForkJoinPool#setAsyncMode}. * - *

ForkJoinTasks are {@code Serializable}, which enables them - * to be used in extensions such as remote execution frameworks. It is - * in general sensible to serialize tasks only before or after, but - * not during execution. Serialization is not relied on during - * execution itself. + *

ForkJoinTasks are {@code Serializable}, which enables them to be + * used in extensions such as remote execution frameworks. It is + * sensible to serialize tasks only before or after, but not during, + * execution. Serialization is not relied on during execution itself. * * @since 1.7 * @author Doug Lea @@ -494,13 +496,15 @@ public abstract class ForkJoinTask im /** * Arranges to asynchronously execute this task. While it is not * necessarily enforced, it is a usage error to fork a task more - * than once unless it has completed and been reinitialized. This - * method may be invoked only from within ForkJoinTask - * computations (as may be determined using method {@link - * #inForkJoinPool}). Attempts to invoke in other contexts result - * in exceptions or errors, possibly including ClassCastException. + * than once unless it has completed and been reinitialized. * - * @return {@code this}, to simplify usage. + *

This method may be invoked only from within {@code + * ForkJoinTask} computations (as may be determined using method + * {@link #inForkJoinPool}). Attempts to invoke in other contexts + * result in exceptions or errors, possibly including {@code + * ClassCastException}. + * + * @return {@code this}, to simplify usage */ public final ForkJoinTask fork() { ((ForkJoinWorkerThread) Thread.currentThread()) @@ -510,9 +514,9 @@ public abstract class ForkJoinTask im /** * Returns the result of the computation when it is ready. - * This method differs from {@code get} in that abnormal - * completion results in RuntimeExceptions or Errors, not - * ExecutionExceptions. + * This method differs from {@link #get()} in that + * abnormal completion results in {@code RuntimeException} or + * {@code Error}, not {@code ExecutionException}. * * @return the computed result */ @@ -539,19 +543,21 @@ public abstract class ForkJoinTask im } /** - * Forks the given tasks, returning when {@code isDone} holds for - * each task or an exception is encountered. This method may be - * invoked only from within ForkJoinTask computations (as may be - * determined using method {@link #inForkJoinPool}). Attempts to - * invoke in other contexts result in exceptions or errors, - * possibly including ClassCastException. + * Forks the given tasks, returning when {@code isDone} holds + * for each task or an exception is encountered. + * + *

This method may be invoked only from within {@code + * ForkJoinTask} computations (as may be determined using method + * {@link #inForkJoinPool}). Attempts to invoke in other contexts + * result in exceptions or errors, possibly including {@code + * ClassCastException}. * * @param t1 the first task * @param t2 the second task * @throws NullPointerException if any task is null * @throws RuntimeException or Error if a task did so */ - public static void invokeAll(ForkJoinTaskt1, ForkJoinTask t2) { + public static void invokeAll(ForkJoinTask t1, ForkJoinTask t2) { t2.fork(); t1.invoke(); t2.join(); @@ -561,14 +567,13 @@ public abstract class ForkJoinTask im * Forks the given tasks, returning when {@code isDone} holds for * each task or an exception is encountered. If any task * encounters an exception, others may be, but are not guaranteed - * to be, cancelled. This method may be invoked only from within - * ForkJoinTask computations (as may be determined using method - * {@link #inForkJoinPool}). Attempts to invoke in other contexts - * result in exceptions or errors, possibly including - * ClassCastException. + * to be, cancelled. * - * Overloadings of this method exist for the special cases - * of one to four arguments. + *

This method may be invoked only from within {@code + * ForkJoinTask} computations (as may be determined using method + * {@link #inForkJoinPool}). Attempts to invoke in other contexts + * result in exceptions or errors, possibly including {@code + * ClassCastException}. * * @param tasks the tasks * @throws NullPointerException if tasks or any element are null @@ -608,14 +613,18 @@ public abstract class ForkJoinTask im } /** - * Forks all tasks in the collection, returning when {@code - * isDone} holds for each task or an exception is encountered. If - * any task encounters an exception, others may be, but are not - * guaranteed to be, cancelled. This method may be invoked only - * from within ForkJoinTask computations (as may be determined - * using method {@link #inForkJoinPool}). Attempts to invoke in - * other contexts result in exceptions or errors, possibly - * including ClassCastException. + * Forks all tasks in the specified collection, returning when + * {@code isDone} holds for each task or an exception is + * encountered. If any task encounters an exception, others may + * be, but are not guaranteed to be, cancelled. The behavior of + * this operation is undefined if the specified collection is + * modified while the operation is in progress. + * + *

This method may be invoked only from within {@code + * ForkJoinTask} computations (as may be determined using method + * {@link #inForkJoinPool}). Attempts to invoke in other contexts + * result in exceptions or errors, possibly including {@code + * ClassCastException}. * * @param tasks the collection of tasks * @return the tasks argument, to simplify usage @@ -623,7 +632,7 @@ public abstract class ForkJoinTask im * @throws RuntimeException or Error if any task did so */ public static > Collection invokeAll(Collection tasks) { - if (!(tasks instanceof List)) { + if (!(tasks instanceof RandomAccess) || !(tasks instanceof List)) { invokeAll(tasks.toArray(new ForkJoinTask[tasks.size()])); return tasks; } @@ -683,28 +692,25 @@ public abstract class ForkJoinTask im } /** - * Asserts that the results of this task's computation will not be - * used. If a cancellation occurs before attempting to execute this - * task, execution will be suppressed, {@link #isCancelled} - * will report true, and {@link #join} will result in a - * {@code CancellationException} being thrown. Otherwise, when - * cancellation races with completion, there are no guarantees - * about whether {@code isCancelled} will report {@code true}, - * whether {@code join} will return normally or via an exception, - * or whether these behaviors will remain consistent upon repeated - * invocation. + * Attempts to cancel execution of this task. This attempt will + * fail if the task has already completed, has already been + * cancelled, or could not be cancelled for some other reason. If + * successful, and this task has not started when cancel is + * called, execution of this task is suppressed, {@link + * #isCancelled} will report true, and {@link #join} will result + * in a {@code CancellationException} being thrown. * *

This method may be overridden in subclasses, but if so, must * still ensure that these minimal properties hold. In particular, - * the cancel method itself must not throw exceptions. + * the {@code cancel} method itself must not throw exceptions. * - *

This method is designed to be invoked by other + *

This method is designed to be invoked by other * tasks. To terminate the current task, you can just return or * throw an unchecked exception from its computation method, or * invoke {@link #completeExceptionally}. * * @param mayInterruptIfRunning this value is ignored in the - * default implementation because tasks are not in general + * default implementation because tasks are not * cancelled via interruption * * @return {@code true} if this task is now cancelled @@ -725,8 +731,8 @@ public abstract class ForkJoinTask im /** * Returns the exception thrown by the base computation, or a - * CancellationException if cancelled, or null if none or if the - * method has not yet completed. + * {@code CancellationException} if cancelled, or {@code null} if + * none or if the method has not yet completed. * * @return the exception, or {@code null} if none */ @@ -804,11 +810,13 @@ public abstract class ForkJoinTask im * there are no potential dependencies between continuation of the * current task and that of any other task that might be executed * while helping. (This usually holds for pure divide-and-conquer - * tasks). This method may be invoked only from within - * ForkJoinTask computations (as may be determined using method - * {@link #inForkJoinPool}). Attempts to invoke in other contexts - * result in exceptions or errors, possibly including - * ClassCastException. + * tasks). + * + *

This method may be invoked only from within {@code + * ForkJoinTask} computations (as may be determined using method + * {@link #inForkJoinPool}). Attempts to invoke in other contexts + * result in exceptions or errors, possibly including {@code + * ClassCastException}. * * @return the computed result */ @@ -821,10 +829,14 @@ public abstract class ForkJoinTask im /** * Possibly executes other tasks until this task is ready. This - * method may be invoked only from within ForkJoinTask - * computations (as may be determined using method {@link - * #inForkJoinPool}). Attempts to invoke in other contexts result - * in exceptions or errors, possibly including ClassCastException. + * method may be useful when processing collections of tasks when + * some have been cancelled or otherwise known to have aborted. + * + *

This method may be invoked only from within {@code + * ForkJoinTask} computations (as may be determined using method + * {@link #inForkJoinPool}). Attempts to invoke in other contexts + * result in exceptions or errors, possibly including {@code + * ClassCastException}. */ public final void quietlyHelpJoin() { if (status >= 0) { @@ -863,13 +875,16 @@ public abstract class ForkJoinTask im /** * Possibly executes tasks until the pool hosting the current task - * {@link ForkJoinPool#isQuiescent}. This method may be of use in - * designs in which many tasks are forked, but none are explicitly - * joined, instead executing them until all are processed. This - * method may be invoked only from within ForkJoinTask - * computations (as may be determined using method {@link - * #inForkJoinPool}). Attempts to invoke in other contexts result - * in exceptions or errors, possibly including ClassCastException. + * {@link ForkJoinPool#isQuiescent is quiescent}. This method may + * be of use in designs in which many tasks are forked, but none + * are explicitly joined, instead executing them until all are + * processed. + * + *

This method may be invoked only from within {@code + * ForkJoinTask} computations (as may be determined using method + * {@link #inForkJoinPool}). Attempts to invoke in other contexts + * result in exceptions or errors, possibly including {@code + * ClassCastException}. */ public static void helpQuiesce() { ((ForkJoinWorkerThread) Thread.currentThread()) @@ -882,8 +897,8 @@ public abstract class ForkJoinTask im * this task, but only if reuse occurs when this task has either * never been forked, or has been forked, then completed and all * outstanding joins of this task have also completed. Effects - * under any other usage conditions are not guaranteed, and are - * discouraged. This method may be useful when executing + * under any other usage conditions are not guaranteed. + * This method may be useful when executing * pre-constructed trees of subtasks in loops. */ public void reinitialize() { @@ -922,11 +937,13 @@ public abstract class ForkJoinTask im * by the current thread, and has not commenced executing in * another thread. This method may be useful when arranging * alternative local processing of tasks that could have been, but - * were not, stolen. This method may be invoked only from within - * ForkJoinTask computations (as may be determined using method - * {@link #inForkJoinPool}). Attempts to invoke in other contexts - * result in exceptions or errors, possibly including - * ClassCastException. + * were not, stolen. + * + *

This method may be invoked only from within {@code + * ForkJoinTask} computations (as may be determined using method + * {@link #inForkJoinPool}). Attempts to invoke in other contexts + * result in exceptions or errors, possibly including {@code + * ClassCastException}. * * @return {@code true} if unforked */ @@ -939,11 +956,14 @@ public abstract class ForkJoinTask im * Returns an estimate of the number of tasks that have been * forked by the current worker thread but not yet executed. This * value may be useful for heuristic decisions about whether to - * fork other tasks. This method may be invoked only from within - * ForkJoinTask computations (as may be determined using method - * {@link #inForkJoinPool}). Attempts to invoke in other contexts - * result in exceptions or errors, possibly including - * ClassCastException. + * fork other tasks. + * + *

This method may be invoked only from within {@code + * ForkJoinTask} computations (as may be determined using method + * {@link #inForkJoinPool}). Attempts to invoke in other contexts + * result in exceptions or errors, possibly including {@code + * ClassCastException}. + * * @return the number of tasks */ public static int getQueuedTaskCount() { @@ -959,11 +979,14 @@ public abstract class ForkJoinTask im * usages of ForkJoinTasks, at steady state, each worker should * aim to maintain a small constant surplus (for example, 3) of * tasks, and to process computations locally if this threshold is - * exceeded. This method may be invoked only from within - * ForkJoinTask computations (as may be determined using method - * {@link #inForkJoinPool}). Attempts to invoke in other contexts - * result in exceptions or errors, possibly including - * ClassCastException. * + * exceeded. + * + *

This method may be invoked only from within {@code + * ForkJoinTask} computations (as may be determined using method + * {@link #inForkJoinPool}). Attempts to invoke in other contexts + * result in exceptions or errors, possibly including {@code + * ClassCastException}. + * * @return the surplus number of tasks, which may be negative */ public static int getSurplusQueuedTaskCount() { @@ -1015,11 +1038,13 @@ public abstract class ForkJoinTask im * null even if a task exists but cannot be accessed without * contention with other threads. This method is designed * primarily to support extensions, and is unlikely to be useful - * otherwise. This method may be invoked only from within - * ForkJoinTask computations (as may be determined using method - * {@link #inForkJoinPool}). Attempts to invoke in other contexts - * result in exceptions or errors, possibly including - * ClassCastException. + * otherwise. + * + *

This method may be invoked only from within {@code + * ForkJoinTask} computations (as may be determined using method + * {@link #inForkJoinPool}). Attempts to invoke in other contexts + * result in exceptions or errors, possibly including {@code + * ClassCastException}. * * @return the next task, or {@code null} if none are available */ @@ -1032,11 +1057,13 @@ public abstract class ForkJoinTask im * Unschedules and returns, without executing, the next task * queued by the current thread but not yet executed. This method * is designed primarily to support extensions, and is unlikely to - * be useful otherwise. This method may be invoked only from - * within ForkJoinTask computations (as may be determined using - * method {@link #inForkJoinPool}). Attempts to invoke in other - * contexts result in exceptions or errors, possibly including - * ClassCastException. + * be useful otherwise. + * + *

This method may be invoked only from within {@code + * ForkJoinTask} computations (as may be determined using method + * {@link #inForkJoinPool}). Attempts to invoke in other contexts + * result in exceptions or errors, possibly including {@code + * ClassCastException}. * * @return the next task, or {@code null} if none are available */ @@ -1053,11 +1080,13 @@ public abstract class ForkJoinTask im * {@code null} result does not necessarily imply quiescence * of the pool this task is operating in. This method is designed * primarily to support extensions, and is unlikely to be useful - * otherwise. This method may be invoked only from within - * ForkJoinTask computations (as may be determined using method - * {@link #inForkJoinPool}). Attempts to invoke in other contexts - * result in exceptions or errors, possibly including - * ClassCastException. + * otherwise. + * + *

This method may be invoked only from within {@code + * ForkJoinTask} computations (as may be determined using method + * {@link #inForkJoinPool}). Attempts to invoke in other contexts + * result in exceptions or errors, possibly including {@code + * ClassCastException}. * * @return a task, or {@code null} if none are available */ @@ -1122,9 +1151,9 @@ public abstract class ForkJoinTask im } /** - * Returns a new ForkJoinTask that performs the {@code run} - * method of the given Runnable as its action, and returns a null - * result upon {@code join}. + * Returns a new {@code ForkJoinTask} that performs the {@code run} + * method of the given {@code Runnable} as its action, and returns + * a null result upon {@link #join}. * * @param runnable the runnable action * @return the task @@ -1134,9 +1163,9 @@ public abstract class ForkJoinTask im } /** - * Returns a new ForkJoinTask that performs the {@code run} - * method of the given Runnable as its action, and returns the - * given result upon {@code join}. + * Returns a new {@code ForkJoinTask} that performs the {@code run} + * method of the given {@code Runnable} as its action, and returns + * the given result upon {@link #join}. * * @param runnable the runnable action * @param result the result upon completion @@ -1147,10 +1176,10 @@ public abstract class ForkJoinTask im } /** - * Returns a new ForkJoinTask that performs the {@code call} - * method of the given Callable as its action, and returns its - * result upon {@code join}, translating any checked - * exceptions encountered into {@code RuntimeException}. + * Returns a new {@code ForkJoinTask} that performs the {@code call} + * method of the given {@code Callable} as its action, and returns + * its result upon {@link #join}, translating any checked exceptions + * encountered into {@code RuntimeException}. * * @param callable the callable action * @return the task