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.54 by dl, Wed Aug 11 19:44:30 2010 UTC vs.
Revision 1.57 by dl, Sat Sep 4 11:33:53 2010 UTC

# Line 100 | Line 100 | import java.util.WeakHashMap;
100   * ForkJoinTasks (as may be determined using method {@link
101   * #inForkJoinPool}).  Attempts to invoke them in other contexts
102   * result in exceptions or errors, possibly including
103 < * ClassCastException.
103 > * {@code ClassCastException}.
104   *
105   * <p>Most base support methods are {@code final}, to prevent
106   * overriding of implementations that are intrinsically tied to the
# Line 153 | Line 153 | public abstract class ForkJoinTask<V> im
153       * single int to minimize footprint and to ensure atomicity (via
154       * CAS).  Status is initially zero, and takes on nonnegative
155       * values until completed, upon which status holds value
156 <     * COMPLETED. CANCELLED, or EXCEPTIONAL. Tasks undergoing blocking
156 >     * NORMAL. CANCELLED, or EXCEPTIONAL. Tasks undergoing blocking
157       * waits by other threads have the SIGNAL bit set.  Completion of
158       * a stolen task with SIGNAL set awakens any waiters via
159       * notifyAll. Even though suboptimal for some purposes, we use
# Line 205 | Line 205 | public abstract class ForkJoinTask<V> im
205      }
206  
207      /**
208 <     * Record exception and set exceptional completion
208 >     * Records exception and sets exceptional completion.
209 >     *
210       * @return status on exit
211       */
212      private void setExceptionalCompletion(Throwable rex) {
# Line 214 | Line 215 | public abstract class ForkJoinTask<V> im
215      }
216  
217      /**
218 <     * Blocks a worker thread until completion. Called only by pool.
218 >     * Blocks a worker thread until completion. Called only by
219 >     * pool. Currently unused -- pool-based waits use timeout
220 >     * version below.
221       */
222      final void internalAwaitDone() {
223          int s;         // the odd construction reduces lock bias effects
# Line 231 | Line 234 | public abstract class ForkJoinTask<V> im
234      }
235  
236      /**
237 +     * Blocks a worker thread until completed or timed out.  Called
238 +     * only by pool.
239 +     *
240 +     * @return status on exit
241 +     */
242 +    final int internalAwaitDone(long millis) {
243 +        int s;
244 +        if ((s = status) >= 0) {
245 +            try {
246 +                synchronized(this) {
247 +                    if (UNSAFE.compareAndSwapInt(this, statusOffset, s,SIGNAL))
248 +                        wait(millis, 0);
249 +                }
250 +            } catch (InterruptedException ie) {
251 +                cancelIfTerminating();
252 +            }
253 +            s = status;
254 +        }
255 +        return s;
256 +    }
257 +
258 +    /**
259       * Blocks a non-worker-thread until completion.
260       */
261      private void externalAwaitDone() {
# Line 314 | Line 339 | public abstract class ForkJoinTask<V> im
339  
340      /**
341       * Commences performing this task, awaits its completion if
342 <     * necessary, and return its result, or throws an (unchecked)
343 <     * exception if the underlying computation did so.
342 >     * necessary, and returns its result, or throws an (unchecked)
343 >     * {@code RuntimeException} or {@code Error} if the underlying
344 >     * computation did so.
345       *
346       * @return the computed result
347       */
# Line 330 | Line 356 | public abstract class ForkJoinTask<V> im
356      /**
357       * Forks the given tasks, returning when {@code isDone} holds for
358       * each task or an (unchecked) exception is encountered, in which
359 <     * case the exception is rethrown.  If either task encounters an
360 <     * exception, the other one may be, but is not guaranteed to be,
361 <     * cancelled.  If both tasks throw an exception, then this method
362 <     * throws one of them.  The individual status of each task may be
363 <     * checked using {@link #getException()} and related methods.
359 >     * case the exception is rethrown. If more than one task
360 >     * encounters an exception, then this method throws any one of
361 >     * these exceptions. If any task encounters an exception, the
362 >     * other may be cancelled. However, the execution status of
363 >     * individual tasks is not guaranteed upon exceptional return. The
364 >     * status of each task may be obtained using {@link
365 >     * #getException()} and related methods to check if they have been
366 >     * cancelled, completed normally or exceptionally, or left
367 >     * unprocessed.
368       *
369       * <p>This method may be invoked only from within {@code
370       * ForkJoinTask} computations (as may be determined using method
# Line 355 | Line 385 | public abstract class ForkJoinTask<V> im
385      /**
386       * Forks the given tasks, returning when {@code isDone} holds for
387       * each task or an (unchecked) exception is encountered, in which
388 <     * case the exception is rethrown. If any task encounters an
389 <     * exception, others may be, but are not guaranteed to be,
390 <     * cancelled.  If more than one task encounters an exception, then
391 <     * this method throws any one of these exceptions.  The individual
392 <     * status of each task may be checked using {@link #getException()}
393 <     * and related methods.
388 >     * case the exception is rethrown. If more than one task
389 >     * encounters an exception, then this method throws any one of
390 >     * these exceptions. If any task encounters an exception, others
391 >     * may be cancelled. However, the execution status of individual
392 >     * tasks is not guaranteed upon exceptional return. The status of
393 >     * each task may be obtained using {@link #getException()} and
394 >     * related methods to check if they have been cancelled, completed
395 >     * normally or exceptionally, or left unprocessed.
396       *
397       * <p>This method may be invoked only from within {@code
398       * ForkJoinTask} computations (as may be determined using method
# Line 407 | Line 439 | public abstract class ForkJoinTask<V> im
439      /**
440       * Forks all tasks in the specified collection, returning when
441       * {@code isDone} holds for each task or an (unchecked) exception
442 <     * is encountered.  If any task encounters an exception, others
443 <     * may be, but are not guaranteed to be, cancelled.  If more than
444 <     * one task encounters an exception, then this method throws any
445 <     * one of these exceptions.  The individual status of each task
446 <     * may be checked using {@link #getException()} and related
447 <     * methods.  The behavior of this operation is undefined if the
448 <     * specified collection is modified while the operation is in
449 <     * progress.
442 >     * is encountered, in which case the exception is rethrown. If
443 >     * more than one task encounters an exception, then this method
444 >     * throws any one of these exceptions. If any task encounters an
445 >     * exception, others may be cancelled. However, the execution
446 >     * status of individual tasks is not guaranteed upon exceptional
447 >     * return. The status of each task may be obtained using {@link
448 >     * #getException()} and related methods to check if they have been
449 >     * cancelled, completed normally or exceptionally, or left
450 >     * unprocessed.
451       *
452       * <p>This method may be invoked only from within {@code
453       * ForkJoinTask} computations (as may be determined using method
# Line 510 | Line 543 | public abstract class ForkJoinTask<V> im
543      }
544  
545      /**
546 <     * Cancels ignoring exceptions if worker is terminating
546 >     * Cancels if current thread is a terminating worker thread,
547 >     * ignoring any exceptions thrown by cancel.
548       */
549      final void cancelIfTerminating() {
550          Thread t = Thread.currentThread();
# Line 1069 | Line 1103 | public abstract class ForkJoinTask<V> im
1103      private static final long serialVersionUID = -7721805057305804111L;
1104  
1105      /**
1106 <     * Saves the state to a stream.
1106 >     * Saves the state to a stream (that is, serializes it).
1107       *
1108       * @serialData the current run status and the exception thrown
1109       * during execution, or {@code null} if none
# Line 1082 | Line 1116 | public abstract class ForkJoinTask<V> im
1116      }
1117  
1118      /**
1119 <     * Reconstitutes the instance from a stream.
1119 >     * Reconstitutes the instance from a stream (that is, deserializes it).
1120       *
1121       * @param s the stream
1122       */

Diff Legend

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