--- jsr166/src/jsr166y/ForkJoinTask.java	2009/08/04 13:16:54	1.36
+++ jsr166/src/jsr166y/ForkJoinTask.java	2009/08/05 00:57:41	1.39
@@ -89,7 +89,7 @@ import java.util.WeakHashMap;
  * (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. 
+ * encountered an exception.
  *
  * <p>The ForkJoinTask class is not usually directly subclassed.
  * Instead, you subclass one of the abstract classes that support a
@@ -125,11 +125,11 @@ import java.util.WeakHashMap;
  * improve throughput. If too small, then memory and internal task
  * maintenance overhead may overwhelm processing.
  *
- * <p>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 async mode}.
+ * <p>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}.
  *
  * <p>ForkJoinTasks are {@code Serializable}, which enables them to be
  * used in extensions such as remote execution frameworks. It is
@@ -392,10 +392,11 @@ public abstract class ForkJoinTask<V> 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;
@@ -421,11 +422,12 @@ public abstract class ForkJoinTask<V> im
         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);
-        throw new TimeoutException();
+        else
+            throw new TimeoutException();
     }
 
     // internal execution methods
@@ -558,9 +560,10 @@ public abstract class ForkJoinTask<V> im
     /**
      * 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 more than one task
-     * encounters an exception, then this method throws any one of
-     * these exceptions.  The individual status of each task may be
+     * 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.
      *
      * <p>This method may be invoked only from within {@code
@@ -780,11 +783,9 @@ public abstract class ForkJoinTask<V> 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));
     }
 
     /**