ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/jsr166y/ForkJoinTask.java
(Generate patch)

Comparing jsr166/src/jsr166y/ForkJoinTask.java (file contents):
Revision 1.34 by dl, Tue Aug 4 11:44:33 2009 UTC vs.
Revision 1.38 by dl, Tue Aug 4 22:47:08 2009 UTC

# Line 68 | Line 68 | import java.util.WeakHashMap;
68   * execute other tasks while awaiting joins, which is sometimes more
69   * efficient but only applies when all subtasks are known to be
70   * strictly tree-structured. Method {@link #invoke} is semantically
71 < * equivalent to {@code fork(); join()} but always attempts to
72 < * begin execution in the current thread. The "<em>quiet</em>" forms
73 < * of these methods do not extract results or report exceptions. These
71 > * equivalent to {@code fork(); join()} but always attempts to begin
72 > * execution in the current thread. The "<em>quiet</em>" forms of
73 > * these methods do not extract results or report exceptions. These
74   * may be useful when a set of tasks are being executed, and you need
75   * to delay processing of results or exceptions until all complete.
76   * Method {@code invokeAll} (available in multiple versions)
77   * performs the most common form of parallel invocation: forking a set
78   * of tasks and joining them all.
79   *
80 + * <p>The execution status of tasks may be queried at several levels
81 + * of detail: {@link #isDone} is true if a task completed in any way
82 + * (including the case where a task was cancelled without executing);
83 + * {@link #isCancelled} is true if completion was due to cancellation;
84 + * {@link #isCompletedNormally} is true if a task completed without
85 + * cancellation or encountering an exception; {@link
86 + * #isCompletedExceptionally} is true if if the task encountered an
87 + * exception (in which case {@link #getException} returns the
88 + * exception); {@link #isCancelled} is true if the task was cancelled
89 + * (in which case {@link #getException} returns a {@link
90 + * java.util.concurrent.CancellationException}); and {@link
91 + * #isCompletedAbnormally} is true if a task was either cancelled or
92 + * encountered an exception.
93 + *
94   * <p>The ForkJoinTask class is not usually directly subclassed.
95   * Instead, you subclass one of the abstract classes that support a
96   * particular style of fork/join processing, typically {@link
# Line 111 | Line 125 | import java.util.WeakHashMap;
125   * improve throughput. If too small, then memory and internal task
126   * maintenance overhead may overwhelm processing.
127   *
128 < * <p>This class provides {@code adapt} methods for {@link
129 < * java.lang.Runnable} and {@link java.util.concurrent.Callable}, that
130 < * may be of use when mixing execution of ForkJoinTasks with other
131 < * kinds of tasks. When all tasks are of this form, consider using a
132 < * pool in {@link ForkJoinPool#setAsyncMode async mode}.
128 > * <p>This class provides {@code adapt} methods for {@link Runnable}
129 > * and {@link Callable}, that may be of use when mixing execution of
130 > * {@code ForkJoinTasks} with other kinds of tasks. When all tasks
131 > * are of this form, consider using a pool in
132 > * {@linkplain ForkJoinPool#setAsyncMode async mode}.
133   *
134   * <p>ForkJoinTasks are {@code Serializable}, which enables them to be
135   * used in extensions such as remote execution frameworks. It is
# Line 378 | Line 392 | public abstract class ForkJoinTask<V> im
392  
393      /**
394       * Returns result or throws exception using j.u.c.Future conventions.
395 <     * Only call when {@code isDone} known to be true.
395 >     * Only call when {@code isDone} known to be true or thread known
396 >     * to be interrupted.
397       */
398      private V reportFutureResult()
399 <        throws ExecutionException, InterruptedException {
399 >        throws InterruptedException, ExecutionException {
400          if (Thread.interrupted())
401              throw new InterruptedException();
402          int s = status & COMPLETION_MASK;
# Line 407 | Line 422 | public abstract class ForkJoinTask<V> im
422          int s = status & COMPLETION_MASK;
423          if (s == NORMAL)
424              return getRawResult();
425 <        if (s == CANCELLED)
425 >        else if (s == CANCELLED)
426              throw new CancellationException();
427 <        if (s == EXCEPTIONAL && (ex = exceptionMap.get(this)) != null)
427 >        else if (s == EXCEPTIONAL && (ex = exceptionMap.get(this)) != null)
428              throw new ExecutionException(ex);
429 <        throw new TimeoutException();
429 >        else
430 >            throw new TimeoutException();
431      }
432  
433      // internal execution methods
# Line 766 | Line 782 | public abstract class ForkJoinTask<V> im
782       */
783      public final Throwable getException() {
784          int s = status & COMPLETION_MASK;
785 <        if (s >= NORMAL)
786 <            return null;
787 <        if (s == CANCELLED)
772 <            return new CancellationException();
773 <        return exceptionMap.get(this);
785 >        return ((s >= NORMAL)    ? null :
786 >                (s == CANCELLED) ? new CancellationException() :
787 >                exceptionMap.get(this));
788      }
789  
790      /**

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines