# ForkJoinTask

public abstract class **ForkJoinTask** extends [Object](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html)  
implements [Future](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/Future.html)\<V\> [Serializable](https://developers.google.com/j2objc/javadoc/jre/reference/java/io/Serializable.html)

|---|---|---|
| Known Direct Subclasses [CountedCompleter](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/CountedCompleter.html)\<T\>, [RecursiveAction](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/RecursiveAction.html), [RecursiveTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/RecursiveTask.html)\<V\> |---|---| | [CountedCompleter](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/CountedCompleter.html)\<T\> | A `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html` with a completion action performed when triggered and there are no remaining pending actions. | | [RecursiveAction](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/RecursiveAction.html) | A recursive resultless `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html`. | | [RecursiveTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/RecursiveTask.html)\<V\> | A recursive result-bearing `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html`. | |||

Abstract base class for tasks that run within a `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinPool.html`.
A `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.

A "main" `ForkJoinTask` begins execution when it is
explicitly submitted to a `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinPool.html`, or, if not already
engaged in a ForkJoin computation, commenced in the `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinPool.html#commonPool()` via `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#fork()`, `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#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 `ForkJoinTask` employ only methods `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#fork()` and
`https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#join()`, or derivatives such as `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#invokeAll(java.util.concurrent.ForkJoinTask<?>...)`. 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.

A `ForkJoinTask` is a lightweight form of `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/Future.html`.
The efficiency of `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 `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#fork()`, that arranges
asynchronous execution, and `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#join()`, that doesn't proceed
until the task's result has been computed. Computations should
ideally avoid `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 `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 `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/RejectedExecutionException.html` 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 `ex.printStackTrace()`) of both the thread
that initiated the computation as well as the thread actually
encountering the exception; minimally only the latter.

It is possible to define and use ForkJoinTasks that may block,
but doing do requires three further considerations: (1) Completion
of few if any *other* 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 `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/CountedCompleter.html`) often fall into this category. (2) To minimize
resource impact, tasks should be small; ideally performing only the
(possibly) blocking action. (3) Unless the `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinPool.ManagedBlocker.html` API is used, or the number of possibly
blocked tasks is known to be less than the pool's `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinPool.html#getParallelism()` level, the pool cannot guarantee that
enough threads will be available to ensure progress or good
performance.

The primary method for awaiting completion and extracting
results of a task is `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#join()`, but there are several variants:
The `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/Future.html#get()` methods support interruptible and/or timed
waits for completion and report results using `Future`
conventions. Method `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#invoke()` is semantically
equivalent to `fork(); join()` but always attempts to begin
execution in the current thread. The "*quiet* " 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 `invokeAll` (available in multiple versions)
performs the most common form of parallel invocation: forking a set
of tasks and joining them all.

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, `a.fork();
b.fork(); b.join(); a.join();` is likely to be substantially more
efficient than joining `a` before `b`.

The execution status of tasks may be queried at several levels
of detail: `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#isDone()` is true if a task completed in any way
(including the case where a task was cancelled without executing);
`https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#isCompletedNormally()` is true if a task completed without
cancellation or encountering an exception; `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#isCancelled()` is
true if the task was cancelled (in which case `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#getException()`
returns a `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/CancellationException.html`); and
`https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#isCompletedAbnormally()` is true if a task was either
cancelled or encountered an exception, in which case `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#getException()` will return either the encountered exception or
`https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/CancellationException.html`.

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 `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/RecursiveAction.html` for most computations that do not return results,
`https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/RecursiveTask.html` for those that do, and `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/CountedCompleter.html` 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 `compute` method that somehow uses the control
methods supplied by this base class.

Method `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#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
`https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/Phaser.html`, `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#helpQuiesce()`, and `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#complete(V)`) 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 *tagged* with a `short`
value using `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#setForkJoinTaskTag(short)` or `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#compareAndSetForkJoinTaskTag(short,%20short)` and checked using `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#getForkJoinTaskTag()`. The ForkJoinTask implementation does not use
these `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.)

Most base support methods are `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 `protected` methods `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#exec()`, `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#setRawResult(V)`, and `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#getRawResult()`, while also introducing
an abstract computational method that can be implemented in its
subclasses, possibly relying on other `protected` methods
provided by this class.

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.

This class provides `adapt` methods for `https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Runnable.html`
and `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/Callable.html`, 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 constructed in *asyncMode*.

ForkJoinTasks are `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.

### Public Constructor Summary

|---|---|
|   | [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#ForkJoinTask())() |

### Public Method Summary

|---|---|
| static \<T\> [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<T\> | [adapt](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#adapt(java.lang.Runnable,%20T))([Runnable](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Runnable.html) runnable, T result) Returns a new `ForkJoinTask` that performs the `run` method of the given `Runnable` as its action, and returns the given result upon `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#join()`. |
| static [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<?\> | [adapt](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#adapt(java.lang.Runnable))([Runnable](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Runnable.html) runnable) Returns a new `ForkJoinTask` that performs the `run` method of the given `Runnable` as its action, and returns a null result upon `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#join()`. |
| static \<T\> [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<T\> | [adapt](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#adapt(java.util.concurrent.Callable<?%20extends%20T>))([Callable](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/Callable.html)\<? extends T\> callable) Returns a new `ForkJoinTask` that performs the `call` method of the given `Callable` as its action, and returns its result upon `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#join()`, translating any checked exceptions encountered into `RuntimeException`. |
| boolean | [cancel](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#cancel(boolean))(boolean mayInterruptIfRunning) Attempts to cancel execution of this task. |
| final boolean | [compareAndSetForkJoinTaskTag](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#compareAndSetForkJoinTaskTag(short,%20short))(short expect, short update) Atomically conditionally sets the tag value for this task. |
| void | [complete](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#complete(V))(V value) Completes this task, and if not already aborted or cancelled, returning the given value as the result of subsequent invocations of `join` and related operations. |
| void | [completeExceptionally](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#completeExceptionally(java.lang.Throwable))([Throwable](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Throwable.html) ex) Completes this task abnormally, and if not already aborted or cancelled, causes it to throw the given exception upon `join` and related operations. |
| final [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<V\> | [fork](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#fork())() Arranges to asynchronously execute this task in the pool the current task is running in, if applicable, or using the `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinPool.html#commonPool()` if not `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#inForkJoinPool()`. |
| final V | [get](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#get(long,%20java.util.concurrent.TimeUnit))(long timeout, [TimeUnit](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/TimeUnit.html) unit) Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available. |
| final V | [get](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#get())() Waits if necessary for the computation to complete, and then retrieves its result. |
| final [Throwable](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Throwable.html) | [getException](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#getException())() Returns the exception thrown by the base computation, or a `CancellationException` if cancelled, or `null` if none or if the method has not yet completed. |
| final short | [getForkJoinTaskTag](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#getForkJoinTaskTag())() Returns the tag for this task. |
| static [ForkJoinPool](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinPool.html) | [getPool](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#getPool())() Returns the pool hosting the current thread, or `null` if the current thread is executing outside of any ForkJoinPool. |
| static int | [getQueuedTaskCount](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#getQueuedTaskCount())() Returns an estimate of the number of tasks that have been forked by the current worker thread but not yet executed. |
| abstract V | [getRawResult](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#getRawResult())() Returns the result that would be returned by `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#join()`, even if this task completed abnormally, or `null` if this task is not known to have been completed. |
| static int | [getSurplusQueuedTaskCount](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#getSurplusQueuedTaskCount())() Returns an estimate of how many more locally queued tasks are held by the current worker thread than there are other worker threads that might steal them, or zero if this thread is not operating in a ForkJoinPool. |
| static void | [helpQuiesce](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#helpQuiesce())() Possibly executes tasks until the pool hosting the current task {@linkplain ForkJoinPool#isQuiescent is quiescent}. |
| static boolean | [inForkJoinPool](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#inForkJoinPool())() Returns `true` if the current thread is a `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinWorkerThread.html` executing as a ForkJoinPool computation. |
| final V | [invoke](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#invoke())() Commences performing this task, awaits its completion if necessary, and returns its result, or throws an (unchecked) `RuntimeException` or `Error` if the underlying computation did so. |
| static void | [invokeAll](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#invokeAll(java.util.concurrent.ForkJoinTask<?>...))([ForkJoinTask...](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<?\> tasks) Forks the given tasks, returning when `isDone` holds for each task or an (unchecked) exception is encountered, in which case the exception is rethrown. |
| static void | [invokeAll](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#invokeAll(java.util.concurrent.ForkJoinTask<?>,%20java.util.concurrent.ForkJoinTask<?>))([ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<?\> t1, [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<?\> t2) Forks the given tasks, returning when `isDone` holds for each task or an (unchecked) exception is encountered, in which case the exception is rethrown. |
| static \<T extends [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<?\>\> [Collection](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html)\<T\> | [invokeAll](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#invokeAll(java.util.Collection<T>))([Collection](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html)\<T\> tasks) Forks all tasks in the specified collection, returning when `isDone` holds for each task or an (unchecked) exception is encountered, in which case the exception is rethrown. |
| final boolean | [isCancelled](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#isCancelled())() Returns `true` if this task was cancelled before it completed normally. |
| final boolean | [isCompletedAbnormally](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#isCompletedAbnormally())() Returns `true` if this task threw an exception or was cancelled. |
| final boolean | [isCompletedNormally](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#isCompletedNormally())() Returns `true` if this task completed without throwing an exception and was not cancelled. |
| final boolean | [isDone](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#isDone())() Returns `true` if this task completed. |
| final V | [join](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#join())() Returns the result of the computation when it `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#isDone()`. |
| final void | [quietlyComplete](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#quietlyComplete())() Completes this task normally without setting a value. |
| final void | [quietlyInvoke](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#quietlyInvoke())() Commences performing this task and awaits its completion if necessary, without returning its result or throwing its exception. |
| final void | [quietlyJoin](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#quietlyJoin())() Joins this task, without returning its result or throwing its exception. |
| void | [reinitialize](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#reinitialize())() Resets the internal bookkeeping state of this task, allowing a subsequent `fork`. |
| final short | [setForkJoinTaskTag](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#setForkJoinTaskTag(short))(short newValue) Atomically sets the tag value for this task and returns the old value. |
| boolean | [tryUnfork](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#tryUnfork())() Tries to unschedule this task for execution. |

### Protected Method Summary

|---|---|
| abstract boolean | [exec](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#exec())() 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. |
| static [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<?\> | [peekNextLocalTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#peekNextLocalTask())() Returns, but does not unschedule or execute, a task queued by the current thread but not yet executed, if one is immediately available. |
| static [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<?\> | [pollNextLocalTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#pollNextLocalTask())() Unschedules and returns, without executing, the next task queued by the current thread but not yet executed, if the current thread is operating in a ForkJoinPool. |
| static [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<?\> | [pollTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#pollTask())() If the current thread is operating in a ForkJoinPool, unschedules and returns, without executing, the next task queued by the current thread but not yet executed, if one is available, or if not available, a task that was forked by some other thread, if available. |
| abstract void | [setRawResult](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#setRawResult(V))(V value) Forces the given value to be returned as a result. |

### Inherited Method Summary

From class [java.lang.Object](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html)

|---|---|
| [Object](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html) | [clone](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html#clone())() Creates and returns a copy of this `Object`. |
| boolean | [equals](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html#equals(java.lang.Object))([Object](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html) obj) Compares this instance with the specified object and indicates if they are equal. |
| void | [finalize](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html#finalize())() Invoked when the garbage collector has detected that this instance is no longer reachable. |
| final [Class](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Class.html)\<?\> | [getClass](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html#getClass())() Returns the unique instance of `https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Class.html` that represents this object's class. |
| int | [hashCode](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html#hashCode())() Returns an integer hash code for this object. |
| final void | [notify](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html#notify())() Causes a thread which is waiting on this object's monitor (by means of calling one of the `wait()` methods) to be woken up. |
| final void | [notifyAll](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html#notifyAll())() Causes all threads which are waiting on this object's monitor (by means of calling one of the `wait()` methods) to be woken up. |
| [String](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/String.html) | [toString](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html#toString())() Returns a string containing a concise, human-readable description of this object. |
| final void | [wait](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html#wait(long,%20int))(long timeout, int nanos) Causes the calling thread to wait until another thread calls the `notify()` or `notifyAll()` method of this object or until the specified timeout expires. |
| final void | [wait](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html#wait(long))(long timeout) Causes the calling thread to wait until another thread calls the `notify()` or `notifyAll()` method of this object or until the specified timeout expires. |
| final void | [wait](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Object.html#wait())() Causes the calling thread to wait until another thread calls the `notify()` or `notifyAll()` method of this object. |

From interface [java.util.concurrent.Future](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/Future.html)

|---|---|
| abstract boolean | [cancel](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/Future.html#cancel(boolean))(boolean mayInterruptIfRunning) Attempts to cancel execution of this task. |
| abstract V | [get](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/Future.html#get(long,%20java.util.concurrent.TimeUnit))(long timeout, [TimeUnit](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/TimeUnit.html) unit) Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available. |
| abstract V | [get](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/Future.html#get())() Waits if necessary for the computation to complete, and then retrieves its result. |
| abstract boolean | [isCancelled](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/Future.html#isCancelled())() Returns `true` if this task was cancelled before it completed normally. |
| abstract boolean | [isDone](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/Future.html#isDone())() Returns `true` if this task completed. |

## Public Constructors

#### public
**ForkJoinTask**
()

<br />

## Public Methods

#### public static [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<T\>
**adapt**
([Runnable](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Runnable.html) runnable, T result)

Returns a new `ForkJoinTask` that performs the `run`
method of the given `Runnable` as its action, and returns
the given result upon `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#join()`.

##### Parameters

| runnable | the runnable action |
| result | the result upon completion |
|---|---|

##### Returns

- the task

#### public static [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<?\>
**adapt**
([Runnable](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Runnable.html) runnable)

Returns a new `ForkJoinTask` that performs the `run`
method of the given `Runnable` as its action, and returns
a null result upon `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#join()`.

##### Parameters

| runnable | the runnable action |
|---|---|

##### Returns

- the task

#### public static [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<T\>
**adapt**
([Callable](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/Callable.html)\<? extends T\> callable)

Returns a new `ForkJoinTask` that performs the `call`
method of the given `Callable` as its action, and returns
its result upon `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#join()`, translating any checked exceptions
encountered into `RuntimeException`.

##### Parameters

| callable | the callable action |
|---|---|

##### Returns

- the task

#### public boolean
**cancel**
(boolean mayInterruptIfRunning)

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 `cancel` is called, execution of
this task is suppressed. After this method returns
successfully, unless there is an intervening call to `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#reinitialize()`, subsequent calls to `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#isCancelled()`,
`https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#isDone()`, and `cancel` will return `true`
and calls to `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#join()` and related methods will result in
`CancellationException`.

This method may be overridden in subclasses, but if so, must
still ensure that these properties hold. In particular, the
`cancel` method itself must not throw exceptions.

This method is designed to be invoked by *other*
tasks. To terminate the current task, you can just return or
throw an unchecked exception from its computation method, or
invoke `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#completeExceptionally(java.lang.Throwable)`.

##### Parameters

| mayInterruptIfRunning | this value has no effect in the default implementation because interrupts are not used to control cancellation. |
|---|---|

##### Returns

- `true` if this task is now cancelled

#### public final boolean
**compareAndSetForkJoinTaskTag**
(short expect, short update)

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: `if (task.compareAndSetForkJoinTaskTag((short)0, (short)1))`
before processing, otherwise exiting because the node has
already been visited.

##### Parameters

| expect | the expected tag value |
| update | the new tag value |
|---|---|

##### Returns

- `true` if successful; i.e., the current value was equal to `expect` and was changed to `update`.

#### public void
**complete**
(V value)

Completes this task, and if not already aborted or cancelled,
returning the given value as the result of subsequent
invocations of `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 `super` implementation to maintain
guarantees.

##### Parameters

| value | the result value for this task |
|---|---|

#### public void
**completeExceptionally**
([Throwable](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Throwable.html) ex)

Completes this task abnormally, and if not already aborted or
cancelled, causes it to throw the given exception upon
`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 `super`
implementation to maintain guarantees.

##### Parameters

| ex | the exception to throw. If this exception is not a `RuntimeException` or `Error`, the actual exception thrown will be a `RuntimeException` with cause `ex`. |
|---|---|

#### public final [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<V\>
**fork**
()

Arranges to asynchronously execute this task in the pool the
current task is running in, if applicable, or using the `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinPool.html#commonPool()` if not `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#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 `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#join()` or
related methods, or a call to `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#isDone()` returning `true`.

##### Returns

- `this`, to simplify usage

#### public final V
**get**
(long timeout, [TimeUnit](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/TimeUnit.html) unit)

Waits if necessary for at most the given time for the computation
to complete, and then retrieves its result, if available.

##### Parameters

| timeout | the maximum time to wait |
| unit | the time unit of the timeout argument |
|---|---|

##### Returns

- the computed result

##### Throws

| [CancellationException](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/CancellationException.html) | if the computation was cancelled |
| [ExecutionException](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ExecutionException.html) | if the computation threw an exception |
| [InterruptedException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/InterruptedException.html) | if the current thread is not a member of a ForkJoinPool and was interrupted while waiting |
| [TimeoutException](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/TimeoutException.html) | if the wait timed out |
|---|---|

#### public final V
**get**
()

Waits if necessary for the computation to complete, and then
retrieves its result.

##### Returns

- the computed result

##### Throws

| [CancellationException](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/CancellationException.html) | if the computation was cancelled |
| [ExecutionException](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ExecutionException.html) | if the computation threw an exception |
| [InterruptedException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/InterruptedException.html) | if the current thread is not a member of a ForkJoinPool and was interrupted while waiting |
|---|---|

#### public final [Throwable](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/Throwable.html)
**getException**
()

Returns the exception thrown by the base computation, or a
`CancellationException` if cancelled, or `null` if
none or if the method has not yet completed.

##### Returns

- the exception, or `null` if none

#### public final short
**getForkJoinTaskTag**
()

Returns the tag for this task.

##### Returns

- the tag for this task

#### public static [ForkJoinPool](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinPool.html)
**getPool**
()

Returns the pool hosting the current thread, or `null`
if the current thread is executing outside of any ForkJoinPool.

This method returns `null` if and only if `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#inForkJoinPool()` returns `false`.

##### Returns

- the pool, or `null` if none

#### public static int
**getQueuedTaskCount**
()

Returns an estimate of the number of tasks that have been
forked by the current worker thread but not yet executed. This
value may be useful for heuristic decisions about whether to
fork other tasks.

##### Returns

- the number of tasks

#### public abstract V
**getRawResult**
()

Returns the result that would be returned by `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#join()`, even
if this task completed abnormally, or `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.

##### Returns

- the result, or `null` if not completed

#### public static int
**getSurplusQueuedTaskCount**
()

Returns an estimate of how many more locally queued tasks are
held by the current worker thread than there are other worker
threads that might steal them, or zero if this thread is not
operating in a ForkJoinPool. This value may be useful for
heuristic decisions about whether to fork other tasks. In many
usages of ForkJoinTasks, at steady state, each worker should
aim to maintain a small constant surplus (for example, 3) of
tasks, and to process computations locally if this threshold is
exceeded.

##### Returns

- the surplus number of tasks, which may be negative

#### public static void
**helpQuiesce**
()

Possibly executes tasks until the pool hosting the current task
{@linkplain ForkJoinPool#isQuiescent is quiescent}. This
method may be of use in designs in which many tasks are forked,
but none are explicitly joined, instead executing them until
all are processed.

#### public static boolean
**inForkJoinPool**
()

Returns `true` if the current thread is a `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinWorkerThread.html` executing as a ForkJoinPool computation.

##### Returns

- `true` if the current thread is a `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinWorkerThread.html` executing as a ForkJoinPool computation, or `false` otherwise

#### public final V
**invoke**
()

Commences performing this task, awaits its completion if
necessary, and returns its result, or throws an (unchecked)
`RuntimeException` or `Error` if the underlying
computation did so.

##### Returns

- the computed result

#### public static void
**invokeAll**
([ForkJoinTask...](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<?\> tasks)

Forks the given tasks, returning when `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 `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#getException()` and
related methods to check if they have been cancelled, completed
normally or exceptionally, or left unprocessed.

##### Parameters

| tasks | the tasks |
|---|---|

##### Throws

| [NullPointerException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/NullPointerException.html) | if any task is null |
|---|---|

#### public static void
**invokeAll**
([ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<?\> t1, [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<?\> t2)

Forks the given tasks, returning when `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 `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#getException()` and related methods to check if they have been
cancelled, completed normally or exceptionally, or left
unprocessed.

##### Parameters

| t1 | the first task |
| t2 | the second task |
|---|---|

##### Throws

| [NullPointerException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/NullPointerException.html) | if any task is null |
|---|---|

#### public static [Collection](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html)\<T\>
**invokeAll**
([Collection](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/Collection.html)\<T\> tasks)

Forks all tasks in the specified collection, returning when
`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 `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#getException()` and related methods to check if they have been
cancelled, completed normally or exceptionally, or left
unprocessed.

##### Parameters

| tasks | the collection of tasks |
|---|---|

##### Returns

- the tasks argument, to simplify usage

##### Throws

| [NullPointerException](https://developers.google.com/j2objc/javadoc/jre/reference/java/lang/NullPointerException.html) | if tasks or any element are null |
|---|---|

#### public final boolean
**isCancelled**
()

Returns `true` if this task was cancelled before it completed
normally.

##### Returns

- `true` if this task was cancelled before it completed

#### public final boolean
**isCompletedAbnormally**
()

Returns `true` if this task threw an exception or was cancelled.

##### Returns

- `true` if this task threw an exception or was cancelled

#### public final boolean
**isCompletedNormally**
()

Returns `true` if this task completed without throwing an
exception and was not cancelled.

##### Returns

- `true` if this task completed without throwing an exception and was not cancelled

#### public final boolean
**isDone**
()

Returns `true` if this task completed.

Completion may be due to normal termination, an exception, or
cancellation -- in all of these cases, this method will return
`true`.

##### Returns

- `true` if this task completed

#### public final V
**join**
()

Returns the result of the computation when it `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#isDone()`. This method differs from `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#get()` in that
abnormal completion results in `RuntimeException` or
`Error`, not `ExecutionException`, and that
interrupts of the calling thread do *not* cause the
method to abruptly return by throwing `InterruptedException`.

##### Returns

- the computed result

#### public final void
**quietlyComplete**
()

Completes this task normally without setting a value. The most
recent value established by `https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html#setRawResult(V)` (or `null` by default) will be returned as the result of subsequent
invocations of `join` and related operations.

#### public final void
**quietlyInvoke**
()

Commences performing this task and awaits its completion if
necessary, without returning its result or throwing its
exception.

#### public final void
**quietlyJoin**
()

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.

#### public void
**reinitialize**
()

Resets the internal bookkeeping state of this task, allowing a
subsequent `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.

Upon completion of this method, `isDone()` reports
`false`, and `getException()` reports `null`. However, the value returned by `getRawResult` is
unaffected. To clear this value, you can invoke `setRawResult(null)`.

#### public final short
**setForkJoinTaskTag**
(short newValue)

Atomically sets the tag value for this task and returns the old value.

##### Parameters

| newValue | the new tag value |
|---|---|

##### Returns

- the previous value of the tag

#### public boolean
**tryUnfork**
()

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

- `true` if unforked

## Protected Methods

#### protected abstract boolean
**exec**
()

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.

##### Returns

- `true` if this task is known to have completed normally

#### protected static [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<?\>
**peekNextLocalTask**
()

Returns, but does not unschedule or execute, a task queued by
the current thread but not yet executed, if one is immediately
available. There is no guarantee that this task will actually
be polled or executed next. Conversely, this method may return
null even if a task exists but cannot be accessed without
contention with other threads. This method is designed
primarily to support extensions, and is unlikely to be useful
otherwise.

##### Returns

- the next task, or `null` if none are available

#### protected static [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<?\>
**pollNextLocalTask**
()

Unschedules and returns, without executing, the next task
queued by the current thread but not yet executed, if the
current thread is operating in a ForkJoinPool. This method is
designed primarily to support extensions, and is unlikely to be
useful otherwise.

##### Returns

- the next task, or `null` if none are available

#### protected static [ForkJoinTask](https://developers.google.com/j2objc/javadoc/jre/reference/java/util/concurrent/ForkJoinTask.html)\<?\>
**pollTask**
()

If the current thread is operating in a ForkJoinPool,
unschedules and returns, without executing, the next task
queued by the current thread but not yet executed, if one is
available, or if not available, a task that was forked by some
other thread, if available. Availability may be transient, so a
`null` result does not necessarily imply quiescence of
the pool this task is operating in. This method is designed
primarily to support extensions, and is unlikely to be useful
otherwise.

##### Returns

- a task, or `null` if none are available

#### protected abstract void
**setRawResult**
(V 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.

##### Parameters

| value | the value |
|---|---|