--- jsr166/src/jsr166y/ForkJoinTask.java 2009/08/04 00:36:45 1.33 +++ jsr166/src/jsr166y/ForkJoinTask.java 2009/10/22 08:19:44 1.45 @@ -56,9 +56,9 @@ import java.util.WeakHashMap; * 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. + * additionally include {@link RejectedExecutionException} 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: @@ -68,15 +68,27 @@ import java.util.WeakHashMap; * execute other tasks while awaiting joins, which is sometimes more * efficient but only applies when all subtasks are known to be * strictly tree-structured. Method {@link #invoke} is semantically - * equivalent to {@code fork(); join()} but always attempts to - * begin execution in the current thread. The "quiet" forms - * of these methods do not extract results or report exceptions. These + * equivalent to {@code fork(); join()} but always attempts to begin + * execution in the current thread. The "quiet" forms of + * these methods do not extract results or report exceptions. These * may be useful when a set of tasks are being executed, and you need * to delay processing of results or exceptions until all complete. * Method {@code invokeAll} (available in multiple versions) * performs the most common form of parallel invocation: forking a set * of tasks and joining them all. * + *

The execution status of tasks may be queried at several levels + * of detail: {@link #isDone} is true if a task completed in any way + * (including the case where a task was cancelled without executing); + * {@link #isCompletedNormally} is true if a task completed without + * cancellation or encountering an exception; {@link #isCancelled} is + * true if the task was cancelled (in which case {@link #getException} + * returns a {@link java.util.concurrent.CancellationException}); and + * {@link #isCompletedAbnormally} is true if a task was either + * cancelled or encountered an exception, in which case {@link + * #getException} will return either the encountered exception or + * {@link java.util.concurrent.CancellationException}. + * *

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 @@ -111,11 +123,11 @@ import java.util.WeakHashMap; * 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 - * may be of use when mixing execution of ForkJoinTasks with other - * kinds of tasks. When all tasks are of this form, consider using a - * pool in {@link ForkJoinPool#setAsyncMode}. + *

This class provides {@code adapt} methods for {@link Runnable} + * and {@link Callable}, that may be of use when mixing execution of + * {@code ForkJoinTasks} with other kinds of tasks. When all tasks + * are of this form, consider using a pool in + * {@linkplain ForkJoinPool#setAsyncMode async mode}. * *

ForkJoinTasks are {@code Serializable}, which enables them to be * used in extensions such as remote execution frameworks. It is @@ -378,10 +390,13 @@ public abstract class ForkJoinTask im /** * Returns result or throws exception using j.u.c.Future conventions. - * Only call when {@code isDone} known to be true. + * Only call when {@code isDone} known to be true or thread known + * to be interrupted. */ private V reportFutureResult() - throws ExecutionException, InterruptedException { + throws InterruptedException, ExecutionException { + if (Thread.interrupted()) + throw new InterruptedException(); int s = status & COMPLETION_MASK; if (s < NORMAL) { Throwable ex; @@ -389,8 +404,6 @@ public abstract class ForkJoinTask im throw new CancellationException(); if (s == EXCEPTIONAL && (ex = exceptionMap.get(this)) != null) throw new ExecutionException(ex); - if (Thread.interrupted()) - throw new InterruptedException(); } return getRawResult(); } @@ -401,17 +414,18 @@ public abstract class ForkJoinTask im */ private V reportTimedFutureResult() throws InterruptedException, ExecutionException, TimeoutException { + if (Thread.interrupted()) + throw new InterruptedException(); Throwable ex; int s = status & COMPLETION_MASK; if (s == NORMAL) return getRawResult(); - if (s == CANCELLED) + else if (s == CANCELLED) throw new CancellationException(); - if (s == EXCEPTIONAL && (ex = exceptionMap.get(this)) != null) + else if (s == EXCEPTIONAL && (ex = exceptionMap.get(this)) != null) throw new ExecutionException(ex); - if (Thread.interrupted()) - throw new InterruptedException(); - throw new TimeoutException(); + else + throw new TimeoutException(); } // internal execution methods @@ -497,6 +511,11 @@ 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. + * Subsequent modifications to the state of this task or any data + * it operates on are not necessarily consistently observable by + * any thread other than the one executing it unless preceded by a + * call to {@link #join} or related methods, or a call to {@link + * #isDone} returning {@code true}. * *

This method may be invoked only from within {@code * ForkJoinTask} computations (as may be determined using method @@ -513,7 +532,7 @@ public abstract class ForkJoinTask im } /** - * Returns the result of the computation when it is ready. + * Returns the result of the computation when it {@link #isDone is done}. * This method differs from {@link #get()} in that * abnormal completion results in {@code RuntimeException} or * {@code Error}, not {@code ExecutionException}. @@ -529,10 +548,9 @@ public abstract class ForkJoinTask im /** * Commences performing this task, awaits its completion if - * necessary, and return its result. + * necessary, and return its result, or throws an (unchecked) + * exception if the underlying computation did so. * - * @throws Throwable (a RuntimeException, Error, or unchecked - * exception) if the underlying computation did so * @return the computed result */ public final V invoke() { @@ -543,8 +561,13 @@ public abstract class ForkJoinTask im } /** - * Forks the given tasks, returning when {@code isDone} holds - * for each task or an exception is encountered. + * Forks the given tasks, returning when {@code isDone} holds for + * each task or an (unchecked) exception is encountered, in which + * case the exception is rethrown. If either task encounters an + * exception, the other one may be, but is not guaranteed to be, + * cancelled. If both tasks throw an exception, then this method + * throws one of them. The individual status of each task may be + * checked using {@link #getException()} and related methods. * *

This method may be invoked only from within {@code * ForkJoinTask} computations (as may be determined using method @@ -555,7 +578,6 @@ public abstract class ForkJoinTask im * @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(ForkJoinTask t1, ForkJoinTask t2) { t2.fork(); @@ -565,9 +587,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. + * each task or an (unchecked) exception is encountered, in which + * case the exception is rethrown. If any task encounters an + * exception, others may be, but are not guaranteed to be, + * cancelled. If more than one task encounters an exception, then + * this method throws any one of these exceptions. The individual + * status of each task may be checked using {@link #getException()} + * and related methods. * *

This method may be invoked only from within {@code * ForkJoinTask} computations (as may be determined using method @@ -576,8 +602,7 @@ public abstract class ForkJoinTask im * ClassCastException}. * * @param tasks the tasks - * @throws NullPointerException if tasks or any element are null - * @throws RuntimeException or Error if any task did so + * @throws NullPointerException if any task is null */ public static void invokeAll(ForkJoinTask... tasks) { Throwable ex = null; @@ -614,11 +639,15 @@ public abstract class ForkJoinTask im /** * 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. + * {@code isDone} holds for each task or an (unchecked) exception + * is encountered. If any task encounters an exception, others + * may be, but are not guaranteed to be, cancelled. If more than + * one task encounters an exception, then this method throws any + * one of these exceptions. The individual status of each task + * may be checked using {@link #getException()} and related + * methods. 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 @@ -629,7 +658,6 @@ public abstract class ForkJoinTask im * @param tasks the collection of tasks * @return the tasks argument, to simplify usage * @throws NullPointerException if tasks or any element are null - * @throws RuntimeException or Error if any task did so */ public static > Collection invokeAll(Collection tasks) { if (!(tasks instanceof RandomAccess) || !(tasks instanceof List)) { @@ -673,25 +701,6 @@ public abstract class ForkJoinTask im } /** - * Returns {@code true} if the computation performed by this task - * has completed (or has been cancelled). - * - * @return {@code true} if this computation has completed - */ - public final boolean isDone() { - return status < 0; - } - - /** - * Returns {@code true} if this task was cancelled. - * - * @return {@code true} if this task was cancelled - */ - public final boolean isCancelled() { - return (status & COMPLETION_MASK) == CANCELLED; - } - - /** * 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 @@ -720,6 +729,14 @@ public abstract class ForkJoinTask im return (status & COMPLETION_MASK) == CANCELLED; } + public final boolean isDone() { + return status < 0; + } + + public final boolean isCancelled() { + return (status & COMPLETION_MASK) == CANCELLED; + } + /** * Returns {@code true} if this task threw an exception or was cancelled. * @@ -730,6 +747,17 @@ public abstract class ForkJoinTask im } /** + * Returns {@code true} if this task completed without throwing an + * exception and was not cancelled. + * + * @return {@code true} if this task completed without throwing an + * exception and was not cancelled + */ + public final boolean isCompletedNormally() { + return (status & COMPLETION_MASK) == NORMAL; + } + + /** * Returns the exception thrown by the base computation, or a * {@code CancellationException} if cancelled, or {@code null} if * none or if the method has not yet completed. @@ -738,11 +766,9 @@ public abstract class ForkJoinTask im */ public final Throwable getException() { int s = status & COMPLETION_MASK; - if (s >= NORMAL) - return null; - if (s == CANCELLED) - return new CancellationException(); - return exceptionMap.get(this); + return ((s >= NORMAL) ? null : + (s == CANCELLED) ? new CancellationException() : + exceptionMap.get(this)); } /** @@ -755,9 +781,9 @@ public abstract class ForkJoinTask im * overridable, but overridden versions must invoke {@code super} * implementation to maintain guarantees. * - * @param ex the exception to throw. If this exception is - * not a RuntimeException or Error, the actual exception thrown - * will be a RuntimeException with cause ex. + * @param ex the exception to throw. If this exception is not a + * {@code RuntimeException} or {@code Error}, the actual exception + * thrown will be a {@code RuntimeException} with cause {@code ex}. */ public void completeExceptionally(Throwable ex) { setDoneExceptionally((ex instanceof RuntimeException) || @@ -804,13 +830,13 @@ public abstract class ForkJoinTask im } /** - * Possibly executes other tasks until this task is ready, then - * returns the result of the computation. This method may be more - * efficient than {@code join}, but is only applicable when - * 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). + * Possibly executes other tasks until this task {@link #isDone is + * done}, then returns the result of the computation. This method + * may be more efficient than {@code join}, but is only applicable + * when 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 {@code * ForkJoinTask} computations (as may be determined using method @@ -828,9 +854,10 @@ public abstract class ForkJoinTask im } /** - * Possibly executes other tasks until this task is ready. This - * method may be useful when processing collections of tasks when - * some have been cancelled or otherwise known to have aborted. + * Possibly executes other tasks until this task {@link #isDone is + * done}. This 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 @@ -1022,11 +1049,10 @@ public abstract class ForkJoinTask im * called otherwise. The return value controls whether this task * is considered to be done normally. It may return false in * asynchronous actions that require explicit invocations of - * {@link #complete} to become joinable. It may throw exceptions - * to indicate abnormal exit. + * {@link #complete} to become joinable. It may also throw an + * (unchecked) exception to indicate abnormal exit. * * @return {@code true} if completed normally - * @throws Error or RuntimeException if encountered during computation */ protected abstract boolean exec(); @@ -1193,7 +1219,7 @@ public abstract class ForkJoinTask im private static final long serialVersionUID = -7721805057305804111L; /** - * Save the state to a stream. + * Saves the state to a stream. * * @serialData the current run status and the exception thrown * during execution, or {@code null} if none @@ -1206,7 +1232,7 @@ public abstract class ForkJoinTask im } /** - * Reconstitute the instance from a stream. + * Reconstitutes the instance from a stream. * * @param s the stream */