--- jsr166/src/jsr166y/ForkJoinTask.java 2009/08/02 17:19:24 1.29 +++ jsr166/src/jsr166y/ForkJoinTask.java 2009/08/03 13:01:15 1.32 @@ -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; @@ -54,7 +55,7 @@ import java.util.WeakHashMap; * 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 + * 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. @@ -85,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 @@ -116,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 @@ -496,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()) @@ -512,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 */ @@ -541,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(); @@ -563,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 @@ -610,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 @@ -625,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; } @@ -806,11 +813,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 */ @@ -823,10 +832,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) { @@ -867,11 +880,13 @@ 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. + * 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()) @@ -884,8 +899,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() { @@ -924,11 +939,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 */ @@ -941,11 +958,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() { @@ -961,11 +981,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() { @@ -1017,11 +1040,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 */ @@ -1034,11 +1059,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 */ @@ -1055,11 +1082,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 */ @@ -1124,9 +1153,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 @@ -1136,9 +1165,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 @@ -1149,10 +1178,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