java.util.concurrent
Class ForkJoinTask<V>

java.lang.Object
  java.util.concurrent.ForkJoinTask<V>

All Implemented Interfaces:

Serializable, Future<V>

Direct Known Subclasses:

RecursiveAction, RecursiveTask

public abstract class ForkJoinTask<V>
extends Object
implements Future<V>, Serializable

Disabled: no SafeJ information.

Abstract base class for tasks that run within a ForkJoinPool. 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 submitted to a ForkJoinPool. 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 fork() and join(), or derivatives such as invokeAll(java.util.concurrent.ForkJoinTask, 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 Future. The efficiency of ForkJoinTasks stems from a set of restrictions (that are only partially statically enforceable) reflecting their intended use as computational tasks calculating pure functions or operating on purely isolated objects. The primary coordination mechanisms are fork(), that arranges asynchronous execution, and join(), that doesn't proceed until the task's result has been computed. Computations should 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. Tasks should also not perform blocking IO, and should ideally access variables that are completely independent of those accessed by other running tasks. Minor breaches of these restrictions, for example using shared output streams, may be tolerable in practice, but frequent use may result in poor performance, and the potential to indefinitely stall if the number of threads not waiting for IO or other external synchronization becomes exhausted. This usage restriction is in part 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 RejectedExecutionException stemming from internal resource exhaustion, such as failure to allocate internal task queues.

The primary method for awaiting completion and extracting results of a task is join(), but there are several variants: The Future.get() methods support interruptible and/or timed waits for completion and report results using Future conventions. Method helpJoin() enables callers to actively execute other tasks while awaiting joins, which is sometimes more efficient but only applies when all subtasks are known to be strictly tree-structured. Method 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.

The execution status of tasks may be queried at several levels of detail: isDone() is true if a task completed in any way (including the case where a task was cancelled without executing); isCompletedNormally() is true if a task completed without cancellation or encountering an exception; isCancelled() is true if the task was cancelled (in which case getException() returns a CancellationException); and isCompletedAbnormally() is true if a task was either cancelled or encountered an exception, in which case getException() will return either the encountered exception or CancellationException.

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 RecursiveAction for computations that do not return results, or RecursiveTask for those that do. 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. While these methods have public access (to allow instances of different task subclasses to call each other's methods), some of them may only be called from within other ForkJoinTasks (as may be determined using method inForkJoinPool()). Attempts to invoke them in other contexts result in exceptions or errors, possibly including ClassCastException.

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 exec(), setRawResult(V), and 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. 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 Runnable and 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 async mode.

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.

Since:

1.7

See Also:

Serialized Form

Constructor Summary

ForkJoinTask()

Method Summary

static <T> ForkJoinTask<T>	adapt(Callable<? extends T> callable) Returns a new ForkJoinTask that performs the call method of the given Callable as its action, and returns its result upon join(), translating any checked exceptions encountered into RuntimeException.
static ForkJoinTask<?>	adapt(Runnable runnable) Returns a new ForkJoinTask that performs the run method of the given Runnable as its action, and returns a null result upon join().
static <T> ForkJoinTask<T>	adapt(Runnable 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 join().
boolean	cancel(boolean mayInterruptIfRunning) Attempts to cancel execution of this task.
void	complete(V value) Completes this task, and if not already aborted or cancelled, returning a null result upon join and related operations.
void	completeExceptionally(Throwable ex) Completes this task abnormally, and if not already aborted or cancelled, causes it to throw the given exception upon join and related operations.
protected abstract boolean	exec() Immediately performs the base action of this task.
ForkJoinTask<V>	fork() Arranges to asynchronously execute this task.
V	get() Waits if necessary for the computation to complete, and then retrieves its result.
V	get(long timeout, TimeUnit unit) Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available.
Throwable	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.
static ForkJoinPool	getPool() Returns the pool hosting the current task execution, or null if this task is executing outside of any ForkJoinPool.
static int	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() Returns the result that would be returned by join(), even if this task completed abnormally, or null if this task is not known to have been completed.
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.
V	helpJoin() Possibly executes other tasks until this task is done, then returns the result of the computation.
static void	helpQuiesce() Possibly executes tasks until the pool hosting the current task is quiescent.
static boolean	inForkJoinPool() Returns true if the current thread is executing as a ForkJoinPool computation.
V	invoke() Commences performing this task, awaits its completion if necessary, and return its result, or throws an (unchecked) exception if the underlying computation did so.
static <T extends ForkJoinTask<?>> Collection<T>	invokeAll(Collection<T> tasks) Forks all tasks in the specified collection, returning when isDone holds for each task or an (unchecked) exception is encountered.
static void	invokeAll(ForkJoinTask<?>... 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(ForkJoinTask<?> t1, ForkJoinTask<?> 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.
boolean	isCancelled() Returns true if this task was cancelled before it completed normally.
boolean	isCompletedAbnormally() Returns true if this task threw an exception or was cancelled.
boolean	isCompletedNormally() Returns true if this task completed without throwing an exception and was not cancelled.
boolean	isDone() Returns true if this task completed.
V	join() Returns the result of the computation when it is done.
protected static ForkJoinTask<?>	peekNextLocalTask() Returns, but does not unschedule or execute, a task queued by the current thread but not yet executed, if one is immediately available.
protected static ForkJoinTask<?>	pollNextLocalTask() Unschedules and returns, without executing, the next task queued by the current thread but not yet executed.
protected static ForkJoinTask<?>	pollTask() 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.
void	quietlyHelpJoin() Possibly executes other tasks until this task is done.
void	quietlyInvoke() Commences performing this task and awaits its completion if necessary, without returning its result or throwing an exception.
void	quietlyJoin() Joins this task, without returning its result or throwing an exception.
void	reinitialize() Resets the internal bookkeeping state of this task, allowing a subsequent fork.
protected abstract void	setRawResult(V value) Forces the given value to be returned as a result.
boolean	tryUnfork() Tries to unschedule this task for execution.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ForkJoinTask

public ForkJoinTask()

Class is disabled.

Method Detail

fork

public final ForkJoinTask<V> fork()

Class is disabled.

Arranges to asynchronously execute this task. 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 join() or related methods, or a call to isDone() returning true.

This method may be invoked only from within ForkJoinTask computations (as may be determined using method inForkJoinPool()). Attempts to invoke in other contexts result in exceptions or errors, possibly including ClassCastException.

Returns:

this, to simplify usage

join

public final V join()

Class is disabled.

Returns the result of the computation when it is done. This method differs from get() in that abnormal completion results in RuntimeException or Error, not ExecutionException.

Returns:

the computed result

invoke

public final V invoke()

Class is disabled.

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

Returns:

the computed result

invokeAll

public static void invokeAll(ForkJoinTask<?> t1,
                             ForkJoinTask<?> t2)

Class is disabled.

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 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 getException() and related methods.

This method may be invoked only from within ForkJoinTask computations (as may be determined using method inForkJoinPool()). Attempts to invoke in other contexts result in exceptions or errors, possibly including ClassCastException.

Parameters:

t1 - the first task

t2 - the second task

Throws:

NullPointerException - if any task is null

invokeAll

public static void invokeAll(ForkJoinTask<?>... tasks)

Class is disabled.

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 any task encounters an exception, others may be, but are not guaranteed to be, cancelled. 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 checked using getException() and related methods.

This method may be invoked only from within ForkJoinTask computations (as may be determined using method inForkJoinPool()). Attempts to invoke in other contexts result in exceptions or errors, possibly including ClassCastException.

Parameters:

tasks - the tasks

Throws:

NullPointerException - if any task is null

invokeAll

public static <T extends ForkJoinTask<?>> Collection<T> invokeAll(Collection<T> tasks)

Class is disabled.

Forks all tasks in the specified collection, returning when isDone holds for each task or an (unchecked) exception is encountered. If any task encounters an exception, others may be, but are not guaranteed to be, cancelled. 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 checked using getException() and related methods. The behavior of this operation is undefined if the specified collection is modified while the operation is in progress.

This method may be invoked only from within ForkJoinTask computations (as may be determined using method inForkJoinPool()). Attempts to invoke in other contexts result in exceptions or errors, possibly including ClassCastException.

Parameters:

tasks - the collection of tasks

Returns:

the tasks argument, to simplify usage

Throws:

NullPointerException - if tasks or any element are null

cancel

public boolean cancel(boolean mayInterruptIfRunning)

Class is disabled.

Attempts to cancel execution of this task. This attempt will fail if the task has already completed, has already been cancelled, 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, isCancelled() will report true, and join() will result in a CancellationException being thrown.

This method may be overridden in subclasses, but if so, must still ensure that these minimal 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 completeExceptionally(java.lang.Throwable).

Specified by:

cancel in interface Future<V>

Parameters:

mayInterruptIfRunning - this value is ignored in the default implementation because tasks are not cancelled via interruption

Returns:

true if this task is now cancelled

isDone

public final boolean isDone()

Class is disabled.

Description copied from interface: Future

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.

Specified by:

isDone in interface Future<V>

Returns:

true if this task completed

isCancelled

public final boolean isCancelled()

Class is disabled.

Description copied from interface: Future

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

Specified by:

isCancelled in interface Future<V>

Returns:

true if this task was cancelled before it completed

isCompletedAbnormally

public final boolean isCompletedAbnormally()

Class is disabled.

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

Returns:

true if this task threw an exception or was cancelled

isCompletedNormally

public final boolean isCompletedNormally()

Class is disabled.

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

getException

public final Throwable getException()

Class is disabled.

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

completeExceptionally

public void completeExceptionally(Throwable ex)

Class is disabled.

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.

complete

public void complete(V value)

Class is disabled.

Completes this task, and if not already aborted or cancelled, returning a null result upon 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

get

public final V get()
            throws InterruptedException,
                   ExecutionException

Class is disabled.

Description copied from interface: Future

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

Specified by:

get in interface Future<V>

Returns:

the computed result

Throws:

InterruptedException - if the current thread was interrupted while waiting

ExecutionException - if the computation threw an exception

get

public final V get(long timeout,
                   TimeUnit unit)
            throws InterruptedException,
                   ExecutionException,
                   TimeoutException

Class is disabled.

Description copied from interface: Future

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

Specified by:

get in interface Future<V>

Parameters:

timeout - the maximum time to wait

unit - the time unit of the timeout argument

Returns:

the computed result

Throws:

InterruptedException - if the current thread was interrupted while waiting

ExecutionException - if the computation threw an exception

TimeoutException - if the wait timed out

helpJoin

public final V helpJoin()

Class is disabled.

Possibly executes other tasks until this task is done, then returns the result of the computation. This method may be more efficient than join, but is only applicable when there are no potential dependencies between continuation of the current task and that of any other task that might be executed while helping. (This usually holds for pure divide-and-conquer tasks).

This method may be invoked only from within ForkJoinTask computations (as may be determined using method inForkJoinPool()). Attempts to invoke in other contexts result in exceptions or errors, possibly including ClassCastException.

Returns:

the computed result

quietlyHelpJoin

public final void quietlyHelpJoin()

Class is disabled.

Possibly executes other tasks until this task is done. This method may be useful when processing collections of tasks when some have been cancelled or otherwise known to have aborted.

This method may be invoked only from within ForkJoinTask computations (as may be determined using method inForkJoinPool()). Attempts to invoke in other contexts result in exceptions or errors, possibly including ClassCastException.

quietlyJoin

public final void quietlyJoin()

Class is disabled.

Joins this task, without returning its result or throwing an exception. This method may be useful when processing collections of tasks when some have been cancelled or otherwise known to have aborted.

quietlyInvoke

public final void quietlyInvoke()

Class is disabled.

Commences performing this task and awaits its completion if necessary, without returning its result or throwing an exception. This method may be useful when processing collections of tasks when some have been cancelled or otherwise known to have aborted.

helpQuiesce

public static void helpQuiesce()

Class is disabled.

Possibly executes tasks until the pool hosting the current task 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.

This method may be invoked only from within ForkJoinTask computations (as may be determined using method inForkJoinPool()). Attempts to invoke in other contexts result in exceptions or errors, possibly including ClassCastException.

reinitialize

public void reinitialize()

Class is disabled.

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.

getPool

public static ForkJoinPool getPool()

Class is disabled.

Returns the pool hosting the current task execution, or null if this task is executing outside of any ForkJoinPool.

Returns:

the pool, or null if none

See Also:

inForkJoinPool()

inForkJoinPool

public static boolean inForkJoinPool()

Class is disabled.

Returns true if the current thread is executing as a ForkJoinPool computation.

Returns:

true if the current thread is executing as a ForkJoinPool computation, or false otherwise

tryUnfork

public boolean tryUnfork()

Class is disabled.

Tries to unschedule this task for execution. This method will typically 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.

This method may be invoked only from within ForkJoinTask computations (as may be determined using method inForkJoinPool()). Attempts to invoke in other contexts result in exceptions or errors, possibly including ClassCastException.

Returns:

true if unforked

getQueuedTaskCount

public static int getQueuedTaskCount()

Class is disabled.

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.

This method may be invoked only from within ForkJoinTask computations (as may be determined using method inForkJoinPool()). Attempts to invoke in other contexts result in exceptions or errors, possibly including ClassCastException.

Returns:

the number of tasks

getSurplusQueuedTaskCount

public static int getSurplusQueuedTaskCount()

Class is disabled.

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. 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.

This method may be invoked only from within ForkJoinTask computations (as may be determined using method inForkJoinPool()). Attempts to invoke in other contexts result in exceptions or errors, possibly including ClassCastException.

Returns:

the surplus number of tasks, which may be negative

getRawResult

public abstract V getRawResult()

Class is disabled.

Returns the result that would be returned by 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

setRawResult

protected abstract void setRawResult(V value)

Class is disabled.

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

exec

protected abstract boolean exec()

Class is disabled.

Immediately performs the base action of this task. This method is designed to support extensions, and should not in general be called otherwise. The return value controls whether this task is considered to be done normally. It may return false in asynchronous actions that require explicit invocations of complete(V) to become joinable. It may also throw an (unchecked) exception to indicate abnormal exit.

Returns:

true if completed normally

peekNextLocalTask

protected static ForkJoinTask<?> peekNextLocalTask()

Class is disabled.

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.

This method may be invoked only from within ForkJoinTask computations (as may be determined using method inForkJoinPool()). Attempts to invoke in other contexts result in exceptions or errors, possibly including ClassCastException.

Returns:

the next task, or null if none are available

pollNextLocalTask

protected static ForkJoinTask<?> pollNextLocalTask()

Class is disabled.

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

This method may be invoked only from within ForkJoinTask computations (as may be determined using method inForkJoinPool()). Attempts to invoke in other contexts result in exceptions or errors, possibly including ClassCastException.

Returns:

the next task, or null if none are available

pollTask

protected static ForkJoinTask<?> pollTask()

Class is disabled.

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.

This method may be invoked only from within ForkJoinTask computations (as may be determined using method inForkJoinPool()). Attempts to invoke in other contexts result in exceptions or errors, possibly including ClassCastException.

Returns:

a task, or null if none are available

adapt

public static ForkJoinTask<?> adapt(Runnable runnable)

Class is disabled.

Returns a new ForkJoinTask that performs the run method of the given Runnable as its action, and returns a null result upon join().

Parameters:

runnable - the runnable action

Returns:

the task

adapt

public static <T> ForkJoinTask<T> adapt(Runnable runnable,
                                        T result)

Class is disabled.

Returns a new ForkJoinTask that performs the run method of the given Runnable as its action, and returns the given result upon join().

Parameters:

runnable - the runnable action

result - the result upon completion

Returns:

the task

adapt

public static <T> ForkJoinTask<T> adapt(Callable<? extends T> callable)

Class is disabled.

Returns a new ForkJoinTask that performs the call method of the given Callable as its action, and returns its result upon join(), translating any checked exceptions encountered into RuntimeException.

Parameters:

callable - the callable action

Returns:

the task