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.39 by jsr166, Wed Aug 5 00:57:41 2009 UTC vs.
Revision 1.42 by dl, Thu Aug 6 23:08:50 2009 UTC

# Line 80 | Line 80 | import java.util.WeakHashMap;
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;
83   * {@link #isCompletedNormally} is true if a task completed without
84 < * cancellation or encountering an exception; {@link
85 < * #isCompletedExceptionally} is true if if the task encountered an
86 < * exception (in which case {@link #getException} returns the
87 < * exception); {@link #isCancelled} is true if the task was cancelled
88 < * (in which case {@link #getException} returns a {@link
89 < * java.util.concurrent.CancellationException}); and {@link
90 < * #isCompletedAbnormally} is true if a task was either cancelled or
92 < * encountered an exception.
84 > * cancellation or encountering an exception; {@link #isCancelled} is
85 > * true if the task was cancelled (in which case {@link #getException}
86 > * returns a {@link java.util.concurrent.CancellationException}); and
87 > * {@link #isCompletedAbnormally} is true if a task was either
88 > * cancelled or encountered an exception, in which case {@link
89 > * #getException} will return either the encountered exception or
90 > * {@link java.util.concurrent.CancellationException}.
91   *
92   * <p>The ForkJoinTask class is not usually directly subclassed.
93   * Instead, you subclass one of the abstract classes that support a
# Line 529 | Line 527 | public abstract class ForkJoinTask<V> im
527      }
528  
529      /**
530 <     * Returns the result of the computation when it is ready.
530 >     * Returns the result of the computation when it {@link #isDone is done}.
531       * This method differs from {@link #get()} in that
532       * abnormal completion results in {@code RuntimeException} or
533       * {@code Error}, not {@code ExecutionException}.
# Line 726 | Line 724 | public abstract class ForkJoinTask<V> im
724          return (status & COMPLETION_MASK) == CANCELLED;
725      }
726  
729    /**
730     * Returns {@code true} if the computation performed by this task
731     * has completed (or has been cancelled).
732     *
733     * @return {@code true} if this computation has completed
734     */
727      public final boolean isDone() {
728          return status < 0;
729      }
730  
739    /**
740     * Returns {@code true} if this task was cancelled.
741     *
742     * @return {@code true} if this task was cancelled
743     */
731      public final boolean isCancelled() {
732          return (status & COMPLETION_MASK) == CANCELLED;
733      }
# Line 766 | Line 753 | public abstract class ForkJoinTask<V> im
753      }
754  
755      /**
769     * Returns {@code true} if this task threw an exception.
770     *
771     * @return {@code true} if this task threw an exception
772     */
773    public final boolean isCompletedExceptionally() {
774        return (status & COMPLETION_MASK) == EXCEPTIONAL;
775    }
776
777    /**
756       * Returns the exception thrown by the base computation, or a
757       * {@code CancellationException} if cancelled, or {@code null} if
758       * none or if the method has not yet completed.
# Line 847 | Line 825 | public abstract class ForkJoinTask<V> im
825      }
826  
827      /**
828 <     * Possibly executes other tasks until this task is ready, then
829 <     * returns the result of the computation.  This method may be more
830 <     * efficient than {@code join}, but is only applicable when
831 <     * there are no potential dependencies between continuation of the
832 <     * current task and that of any other task that might be executed
833 <     * while helping. (This usually holds for pure divide-and-conquer
834 <     * tasks).
828 >     * Possibly executes other tasks until this task {@link #isDone is
829 >     * done}, then returns the result of the computation.  This method
830 >     * may be more efficient than {@code join}, but is only applicable
831 >     * when there are no potential dependencies between continuation
832 >     * of the current task and that of any other task that might be
833 >     * executed while helping. (This usually holds for pure
834 >     * divide-and-conquer tasks).
835       *
836       * <p>This method may be invoked only from within {@code
837       * ForkJoinTask} computations (as may be determined using method
# Line 871 | Line 849 | public abstract class ForkJoinTask<V> im
849      }
850  
851      /**
852 <     * Possibly executes other tasks until this task is ready.  This
853 <     * method may be useful when processing collections of tasks when
854 <     * some have been cancelled or otherwise known to have aborted.
852 >     * Possibly executes other tasks until this task {@link #isDone is
853 >     * done}.  This method may be useful when processing collections
854 >     * of tasks when some have been cancelled or otherwise known to
855 >     * have aborted.
856       *
857       * <p>This method may be invoked only from within {@code
858       * ForkJoinTask} computations (as may be determined using method

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines