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.36 by dl, Tue Aug 4 13:16:54 2009 UTC vs.
Revision 1.37 by jsr166, Tue Aug 4 20:24:54 2009 UTC

# Line 89 | Line 89 | import java.util.WeakHashMap;
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.
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
# Line 125 | 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 395 | Line 395 | public abstract class ForkJoinTask<V> im
395       * Only call when {@code isDone} known to be true.
396       */
397      private V reportFutureResult()
398 <        throws ExecutionException, InterruptedException {
398 >        throws InterruptedException, ExecutionException {
399          if (Thread.interrupted())
400              throw new InterruptedException();
401          int s = status & COMPLETION_MASK;
# Line 421 | Line 421 | public abstract class ForkJoinTask<V> im
421          int s = status & COMPLETION_MASK;
422          if (s == NORMAL)
423              return getRawResult();
424 <        if (s == CANCELLED)
424 >        else if (s == CANCELLED)
425              throw new CancellationException();
426 <        if (s == EXCEPTIONAL && (ex = exceptionMap.get(this)) != null)
426 >        else if (s == EXCEPTIONAL && (ex = exceptionMap.get(this)) != null)
427              throw new ExecutionException(ex);
428 <        throw new TimeoutException();
428 >        else
429 >            throw new TimeoutException();
430      }
431  
432      // internal execution methods
# Line 780 | Line 781 | public abstract class ForkJoinTask<V> im
781       */
782      public final Throwable getException() {
783          int s = status & COMPLETION_MASK;
784 <        if (s >= NORMAL)
785 <            return null;
786 <        if (s == CANCELLED)
786 <            return new CancellationException();
787 <        return exceptionMap.get(this);
784 >        return ((s >= NORMAL)    ? null :
785 >                (s == CANCELLED) ? new CancellationException() :
786 >                exceptionMap.get(this));
787      }
788  
789      /**

Diff Legend

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