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.38 by dl, Tue Aug 4 22:47:08 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 392 | 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 421 | 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 780 | 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)
786 <            return new CancellationException();
787 <        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