| 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 |
| 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 |
| 206 |
|
|
| 207 |
|
/** |
| 208 |
|
* Records exception and sets exceptional completion. |
| 209 |
< |
* |
| 209 |
> |
* |
| 210 |
|
* @return status on exit |
| 211 |
|
*/ |
| 212 |
|
private void setExceptionalCompletion(Throwable rex) { |
| 223 |
|
int s; // the odd construction reduces lock bias effects |
| 224 |
|
while ((s = status) >= 0) { |
| 225 |
|
try { |
| 226 |
< |
synchronized(this) { |
| 226 |
> |
synchronized (this) { |
| 227 |
|
if (UNSAFE.compareAndSwapInt(this, statusOffset, s,SIGNAL)) |
| 228 |
|
wait(); |
| 229 |
|
} |
| 243 |
|
int s; |
| 244 |
|
if ((s = status) >= 0) { |
| 245 |
|
try { |
| 246 |
< |
synchronized(this) { |
| 246 |
> |
synchronized (this) { |
| 247 |
|
if (UNSAFE.compareAndSwapInt(this, statusOffset, s,SIGNAL)) |
| 248 |
|
wait(millis, 0); |
| 249 |
|
} |
| 261 |
|
private void externalAwaitDone() { |
| 262 |
|
int s; |
| 263 |
|
while ((s = status) >= 0) { |
| 264 |
< |
synchronized(this) { |
| 264 |
> |
synchronized (this) { |
| 265 |
|
if (UNSAFE.compareAndSwapInt(this, statusOffset, s, SIGNAL)){ |
| 266 |
|
boolean interrupted = false; |
| 267 |
|
while (status >= 0) { |
| 340 |
|
/** |
| 341 |
|
* Commences performing this task, awaits its completion if |
| 342 |
|
* necessary, and returns its result, or throws an (unchecked) |
| 343 |
< |
* exception if the underlying computation did so. |
| 343 |
> |
* {@code RuntimeException} or {@code Error} if the underlying |
| 344 |
> |
* computation did so. |
| 345 |
|
* |
| 346 |
|
* @return the computed result |
| 347 |
|
*/ |
| 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 |
| 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 |
| 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 |
| 621 |
|
|
| 622 |
|
/** |
| 623 |
|
* Completes this task, and if not already aborted or cancelled, |
| 624 |
< |
* returning a {@code null} result upon {@code join} and related |
| 625 |
< |
* operations. This method may be used to provide results for |
| 626 |
< |
* asynchronous tasks, or to provide alternative handling for |
| 627 |
< |
* tasks that would not otherwise complete normally. Its use in |
| 628 |
< |
* other situations is discouraged. This method is |
| 629 |
< |
* overridable, but overridden versions must invoke {@code super} |
| 630 |
< |
* implementation to maintain guarantees. |
| 624 |
> |
* returning the given value as the result of subsequent |
| 625 |
> |
* invocations of {@code join} and related operations. This method |
| 626 |
> |
* may be used to provide results for asynchronous tasks, or to |
| 627 |
> |
* provide alternative handling for tasks that would not otherwise |
| 628 |
> |
* complete normally. Its use in other situations is |
| 629 |
> |
* discouraged. This method is overridable, but overridden |
| 630 |
> |
* versions must invoke {@code super} implementation to maintain |
| 631 |
> |
* guarantees. |
| 632 |
|
* |
| 633 |
|
* @param value the result value for this task |
| 634 |
|
*/ |
| 680 |
|
boolean dec = false; // true if pool count decremented |
| 681 |
|
long nanos = unit.toNanos(timeout); |
| 682 |
|
for (;;) { |
| 683 |
< |
if (Thread.interrupted() && pool == null) { |
| 683 |
> |
if (pool == null && Thread.interrupted()) { |
| 684 |
|
interrupted = true; |
| 685 |
|
break; |
| 686 |
|
} |
| 698 |
|
long ms = nt / 1000000; |
| 699 |
|
int ns = (int) (nt % 1000000); |
| 700 |
|
try { |
| 701 |
< |
synchronized(this) { |
| 701 |
> |
synchronized (this) { |
| 702 |
|
if (status >= 0) |
| 703 |
|
wait(ms, ns); |
| 704 |
|
} |
| 765 |
|
/** |
| 766 |
|
* Commences performing this task and awaits its completion if |
| 767 |
|
* necessary, without returning its result or throwing its |
| 768 |
< |
* exception. This method may be useful when processing |
| 760 |
< |
* collections of tasks when some have been cancelled or otherwise |
| 761 |
< |
* known to have aborted. |
| 768 |
> |
* exception. |
| 769 |
|
*/ |
| 770 |
|
public final void quietlyInvoke() { |
| 771 |
|
if (status >= 0) { |
