Attempts to cancel execution of this task. This attempt will fail if the task has already completed or could not be cancelled for some other reason. If successful, and this task has not started when {@code cancel} is called, execution of this task is suppressed. After this method returns successfully, unless there is an intervening call to {@link #reinitialize}, subsequent calls to {@link #isCancelled}, {@link #isDone}, and {@code cancel} will return {@code true} and calls to {@link #join} and related methods will result in {@code CancellationException}.
Atomically conditionally sets the tag value for this task. Among other applications, tags can be used as visit markers in tasks operating on graphs, as in methods that check: {@code if (task.compareAndSetForkJoinTaskTag((short)0, (short)1))} before processing, otherwise exiting because the node has already been visited.
Completes this task, and if not already aborted or cancelled, returning the given value as the result of subsequent invocations of {@code join} and related operations. This method may be used to provide results for asynchronous tasks, or to provide alternative handling for tasks that would not otherwise complete normally. Its use in other situations is discouraged. This method is overridable, but overridden versions must invoke {@code super} implementation to maintain guarantees.
Completes this task abnormally, and if not already aborted or cancelled, causes it to throw the given exception upon {@code join} and related operations. This method may be used to induce exceptions in asynchronous tasks, or to force completion of tasks that would not otherwise complete. Its use in other situations is discouraged. This method is overridable, but overridden versions must invoke {@code super} implementation to maintain guarantees.
Primary execution method for stolen tasks. Unless done, calls exec and records status if completed, but doesn't wait for completion otherwise.
Immediately performs the base action of this task and returns true if, upon return from this method, this task is guaranteed to have completed normally. This method may return false otherwise, to indicate that this task is not necessarily complete (or is not known to be complete), for example in asynchronous actions that require explicit invocations of completion methods. This method may also throw an (unchecked) exception to indicate abnormal exit. This method is designed to support extensions, and should not in general be called otherwise.
Arranges to asynchronously execute this task in the pool the current task is running in, if applicable, or using the {@link ForkJoinPool#commonPool()} if not {@link #inForkJoinPool}. While it is not necessarily enforced, it is a usage error to fork a task more than once unless it has completed and been reinitialized. Subsequent modifications to the state of this task or any data it operates on are not necessarily consistently observable by any thread other than the one executing it unless preceded by a call to {@link #join} or related methods, or a call to {@link #isDone} returning {@code true}.
Waits if necessary for the computation to complete, and then retrieves its result.
Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available.
Returns the exception thrown by the base computation, or a {@code CancellationException} if cancelled, or {@code null} if none or if the method has not yet completed.
Returns the tag for this task.
Returns the result that would be returned by {@link #join}, even if this task completed abnormally, or {@code null} if this task is not known to have been completed. This method is designed to aid debugging, as well as to support extensions. Its use in any other context is discouraged.
Hook for exception propagation support for tasks with completers.
If not done, sets SIGNAL status and performs Object.wait(timeout). This task may or may not be done on exit. Ignores interrupts.
Commences performing this task, awaits its completion if necessary, and returns its result, or throws an (unchecked) {@code RuntimeException} or {@code Error} if the underlying computation did so.
Returns {@code true} if this task threw an exception or was cancelled.
Returns {@code true} if this task completed without throwing an exception and was not cancelled.
Returns the result of the computation when it {@linkplain #isDone is done}. This method differs from {@link #get()} in that abnormal completion results in {@code RuntimeException} or {@code Error}, not {@code ExecutionException}, and that interrupts of the calling thread do <em>not</em> cause the method to abruptly return by throwing {@code InterruptedException}.
Completes this task normally without setting a value. The most recent value established by {@link #setRawResult} (or {@code null} by default) will be returned as the result of subsequent invocations of {@code join} and related operations.
Commences performing this task and awaits its completion if necessary, without returning its result or throwing its exception.
Joins this task, without returning its result or throwing its exception. This method may be useful when processing collections of tasks when some have been cancelled or otherwise known to have aborted.
Records exception and sets status.
Resets the internal bookkeeping state of this task, allowing a subsequent {@code fork}. This method allows repeated reuse of this task, but only if reuse occurs when this task has either never been forked, or has been forked, then completed and all outstanding joins of this task have also completed. Effects under any other usage conditions are not guaranteed. This method may be useful when executing pre-constructed trees of subtasks in loops.
Atomically sets the tag value for this task and returns the old value.
Forces the given value to be returned as a result. This method is designed to support extensions, and should not in general be called otherwise.
Tries to unschedule this task for execution. This method will typically (but is not guaranteed to) succeed if this task is the most recently forked task by the current thread, and has not commenced executing in another thread. This method may be useful when arranging alternative local processing of tasks that could have been, but were not, stolen.
Returns a new {@code ForkJoinTask} that performs the {@code run} method of the given {@code Runnable} as its action, and returns the given result upon {@link #join}.
Returns a new {@code ForkJoinTask} that performs the {@code call} method of the given {@code Callable} as its action, and returns its result upon {@link #join}, translating any checked exceptions encountered into {@code RuntimeException}.
Returns {@code true} if the current thread is a {@link ForkJoinWorkerThread} executing as a ForkJoinPool computation.
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. If any task encounters an exception, the other may be cancelled. However, the execution status of individual tasks is not guaranteed upon exceptional return. The status of each task may be obtained using {@link #getException()} and related methods to check if they have been cancelled, completed normally or exceptionally, or left unprocessed.
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. If any task encounters an exception, others may be cancelled. However, the execution status of individual tasks is not guaranteed upon exceptional return. The status of each task may be obtained using {@link #getException()} and related methods to check if they have been cancelled, completed normally or exceptionally, or left unprocessed.
Forks all tasks in the specified collection, 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. If any task encounters an exception, others may be cancelled. However, the execution status of individual tasks is not guaranteed upon exceptional return. The status of each task may be obtained using {@link #getException()} and related methods to check if they have been cancelled, completed normally or exceptionally, or left unprocessed.
The status field holds run control status bits packed into a single int to ensure atomicity. Status is initially zero, and takes on nonnegative values until completed, upon which it holds (sign bit) DONE, possibly with ABNORMAL (cancelled or exceptional) and THROWN (in which case an exception has been stored). Tasks with dependent blocked waiting joiners have the SIGNAL bit set. Completion of a task with SIGNAL set awakens any waiters via notifyAll. (Waiters also help signal others upon completion.)
The status field holds run control status bits packed into a single int to ensure atomicity. Status is initially zero, and takes on nonnegative values until completed, upon which it holds (sign bit) DONE, possibly with ABNORMAL (cancelled or exceptional) and THROWN (in which case an exception has been stored). Tasks with dependent blocked waiting joiners have the SIGNAL bit set. Completion of a task with SIGNAL set awakens any waiters via notifyAll. (Waiters also help signal others upon completion.)
Cancels, ignoring any exceptions thrown by cancel. Used during worker and pool shutdown. Cancel is spec'ed not to throw any exceptions, but if it does anyway, we have no recourse during shutdown, so guard against this case.
Abstract base class for tasks that run within a {@link ForkJoinPool}. A {@code ForkJoinTask} is a thread-like entity that is much lighter weight than a normal thread. Huge numbers of tasks and subtasks may be hosted by a small number of actual threads in a ForkJoinPool, at the price of some usage limitations.
<p>A "main" {@code ForkJoinTask} begins execution when it is explicitly submitted to a {@link ForkJoinPool}, or, if not already engaged in a ForkJoin computation, commenced in the {@link ForkJoinPool#commonPool()} via {@link #fork}, {@link #invoke}, or related methods. Once started, it will usually in turn start other subtasks. As indicated by the name of this class, many programs using {@code ForkJoinTask} employ only methods {@link #fork} and {@link #join}, or derivatives such as {@link #invokeAll(ForkJoinTask...) invokeAll}. However, this class also provides a number of other methods that can come into play in advanced usages, as well as extension mechanics that allow support of new forms of fork/join processing.
<p>A {@code ForkJoinTask} is a lightweight form of {@link Future}. The efficiency of {@code ForkJoinTask}s stems from a set of restrictions (that are only partially statically enforceable) reflecting their main use as computational tasks calculating pure functions or operating on purely isolated objects. The primary coordination mechanisms are {@link #fork}, that arranges asynchronous execution, and {@link #join}, that doesn't proceed until the task's result has been computed. Computations should ideally avoid {@code synchronized} methods or blocks, and should minimize other blocking synchronization apart from joining other tasks or using synchronizers such as Phasers that are advertised to cooperate with fork/join scheduling. Subdividable tasks should also not perform blocking I/O, and should ideally access variables that are completely independent of those accessed by other running tasks. These guidelines are loosely enforced by not permitting checked exceptions such as {@code IOExceptions} to be thrown. However, computations may still encounter unchecked exceptions, that are rethrown to callers attempting to join them. These exceptions may additionally include {@link RejectedExecutionException} stemming from internal resource exhaustion, such as failure to allocate internal task queues. Rethrown exceptions behave in the same way as regular exceptions, but, when possible, contain stack traces (as displayed for example using {@code ex.printStackTrace()}) of both the thread that initiated the computation as well as the thread actually encountering the exception; minimally only the latter.
<p>It is possible to define and use ForkJoinTasks that may block, but doing so requires three further considerations: (1) Completion of few if any <em>other</em> tasks should be dependent on a task that blocks on external synchronization or I/O. Event-style async tasks that are never joined (for example, those subclassing {@link CountedCompleter}) often fall into this category. (2) To minimize resource impact, tasks should be small; ideally performing only the (possibly) blocking action. (3) Unless the {@link ForkJoinPool.ManagedBlocker} API is used, or the number of possibly blocked tasks is known to be less than the pool's {@link ForkJoinPool#getParallelism} level, the pool cannot guarantee that enough threads will be available to ensure progress or good performance.
<p>The primary method for awaiting completion and extracting results of a task is {@link #join}, but there are several variants: The {@link Future#get} methods support interruptible and/or timed waits for completion and report results using {@code Future} conventions. Method {@link #invoke} is semantically equivalent to {@code fork(); join()} but always attempts to begin execution in the current thread. The "<em>quiet</em>" forms of these methods do not extract results or report exceptions. These may be useful when a set of tasks are being executed, and you need to delay processing of results or exceptions until all complete. Method {@code invokeAll} (available in multiple versions) performs the most common form of parallel invocation: forking a set of tasks and joining them all.
<p>In the most typical usages, a fork-join pair act like a call (fork) and return (join) from a parallel recursive function. As is the case with other forms of recursive calls, returns (joins) should be performed innermost-first. For example, {@code a.fork(); b.fork(); b.join(); a.join();} is likely to be substantially more efficient than joining {@code a} before {@code b}.
<p>The execution status of tasks may be queried at several levels of detail: {@link #isDone} is true if a task completed in any way (including the case where a task was cancelled without executing); {@link #isCompletedNormally} is true if a task completed without cancellation or encountering an exception; {@link #isCancelled} is true if the task was cancelled (in which case {@link #getException} returns a {@link CancellationException}); and {@link #isCompletedAbnormally} is true if a task was either cancelled or encountered an exception, in which case {@link #getException} will return either the encountered exception or {@link CancellationException}.
<p>The ForkJoinTask class is not usually directly subclassed. Instead, you subclass one of the abstract classes that support a particular style of fork/join processing, typically {@link RecursiveAction} for most computations that do not return results, {@link RecursiveTask} for those that do, and {@link CountedCompleter} for those in which completed actions trigger other actions. Normally, a concrete ForkJoinTask subclass declares fields comprising its parameters, established in a constructor, and then defines a {@code compute} method that somehow uses the control methods supplied by this base class.
<p>Method {@link #join} and its variants are appropriate for use only when completion dependencies are acyclic; that is, the parallel computation can be described as a directed acyclic graph (DAG). Otherwise, executions may encounter a form of deadlock as tasks cyclically wait for each other. However, this framework supports other methods and techniques (for example the use of {@link Phaser}, {@link #helpQuiesce}, and {@link #complete}) that may be of use in constructing custom subclasses for problems that are not statically structured as DAGs. To support such usages, a ForkJoinTask may be atomically <em>tagged</em> with a {@code short} value using {@link #setForkJoinTaskTag} or {@link #compareAndSetForkJoinTaskTag} and checked using {@link #getForkJoinTaskTag}. The ForkJoinTask implementation does not use these {@code protected} methods or tags for any purpose, but they may be of use in the construction of specialized subclasses. For example, parallel graph traversals can use the supplied methods to avoid revisiting nodes/tasks that have already been processed. (Method names for tagging are bulky in part to encourage definition of methods that reflect their usage patterns.)
<p>Most base support methods are {@code final}, to prevent overriding of implementations that are intrinsically tied to the underlying lightweight task scheduling framework. Developers creating new basic styles of fork/join processing should minimally implement {@code protected} methods {@link #exec}, {@link #setRawResult}, and {@link #getRawResult}, while also introducing an abstract computational method that can be implemented in its subclasses, possibly relying on other {@code protected} methods provided by this class.
<p>ForkJoinTasks should perform relatively small amounts of computation. Large tasks should be split into smaller subtasks, usually via recursive decomposition. As a very rough rule of thumb, a task should perform more than 100 and less than 10000 basic computational steps, and should avoid indefinite looping. If tasks are too big, then parallelism cannot improve throughput. If too small, then memory and internal task maintenance overhead may overwhelm processing.
<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 constructed in <em>asyncMode</em>.
<p>ForkJoinTasks are {@code Serializable}, which enables them to be used in extensions such as remote execution frameworks. It is sensible to serialize tasks only before or after, but not during, execution. Serialization is not relied on during execution itself.
@author Doug Lea