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 it is
explicitly submitted to a
, or, if not already
engaged in a ForkJoin computation, commenced in the ForkJoinPool
via ForkJoinPool.commonPool()
, fork()
, or
related methods. Once started, it will usually in turn start other
subtasks. As indicated by the name of this class, many programs
using invoke()
ForkJoinTask
employ only methods
and
fork()
, or derivatives such as join()
. 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.
invokeAll(org.infinispan.commons.util.concurrent.jdk8backported.ForkJoinTask[])
A ForkJoinTask
is a lightweight form of
.
The efficiency of java.util.concurrent.Future
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
, that arranges
asynchronous execution, and fork()
, that doesn't proceed
until the task's result has been computed. Computations should
ideally avoid join()
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
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 java.util.concurrent.RejectedExecutionException
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
) often fall into this category. (2) To minimize
resource impact, tasks should be small; ideally performing only the
(possibly) blocking action. (3) Unless the CountedCompleter
API is used, or the number of possibly
blocked tasks is known to be less than the pool's ForkJoinPool.ManagedBlocker
level, the pool cannot guarantee that
enough threads will be available to ensure progress or good
performance.
ForkJoinPool.getParallelism()
The primary method for awaiting completion and extracting
results of a task is
, but there are several variants:
The join()
methods support interruptible and/or timed
waits for completion and report results using java.util.concurrent.Future.get()
Future
conventions. Method
is semantically
equivalent to invoke()
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:
is true if a task completed in any way
(including the case where a task was cancelled without executing);
isDone()
is true if a task completed without
cancellation or encountering an exception; isCompletedNormally()
is
true if the task was cancelled (in which case isCancelled()
returns a getException()
); and
java.util.concurrent.CancellationException
is true if a task was either
cancelled or encountered an exception, in which case isCompletedAbnormally()
will return either the encountered exception or
getException()
.
java.util.concurrent.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
for most computations that do not return results,
RecursiveAction
for those that do, and RecursiveTask
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 CountedCompleter
compute
method that somehow uses the control
methods supplied by this base class.
Method
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
join()
, java.util.concurrent.Phaser
, and
helpQuiesce()
) 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 complete(java.lang.Object)
short
value using
or setForkJoinTaskTag(short)
and checked using compareAndSetForkJoinTaskTag(short,short)
. The ForkJoinTask implementation does not use
these getForkJoinTaskTag()
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
, exec()
, and setRawResult(java.lang.Object)
, while also introducing
an abstract computational method that can be implemented in its
subclasses, possibly relying on other getRawResult()
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
and java.lang.Runnable
, that may be of use when mixing execution of
java.util.concurrent.Callable
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.
ForkJoinPool.commonPool()
if not 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 join()
or
related methods, or a call to isDone()
returning true
.
this
, to simplify usageis
done
. This method differs from 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
.
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 getException()
and related methods to check if they have been
cancelled, completed normally or exceptionally, or left
unprocessed.
t1
the first taskt2
the second taskjava.lang.NullPointerException
if any task is nullisDone
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 getException()
and
related methods to check if they have been cancelled, completed
normally or exceptionally, or left unprocessed.
tasks
the tasksjava.lang.NullPointerException
if any task is nullisDone
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 getException()
and related methods to check if they have been
cancelled, completed normally or exceptionally, or left
unprocessed.
tasks
the collection of tasksjava.lang.NullPointerException
if tasks or any element are nullcancel
is called, execution of
this task is suppressed. After this method returns
successfully, unless there is an intervening call to reinitialize()
, subsequent calls to isCancelled()
,
isDone()
, and cancel
will return true
and calls to 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
.
completeExceptionally(java.lang.Throwable)
mayInterruptIfRunning
this value has no effect in the
default implementation because interrupts are not used to
control cancellation.true
if this task is now cancelledjoin
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.
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
.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.
value
the result value for this tasksetRawResult(java.lang.Object)
(or null
by default) will be returned as the result of subsequent
invocations of join
and related operations.
java.util.concurrent.CancellationException
if the computation was cancelledjava.util.concurrent.ExecutionException
if the computation threw an
exceptionjava.lang.InterruptedException
if the current thread is not a
member of a ForkJoinPool and was interrupted while waitingtimeout
the maximum time to waitunit
the time unit of the timeout argumentjava.util.concurrent.CancellationException
if the computation was cancelledjava.util.concurrent.ExecutionException
if the computation threw an
exceptionjava.lang.InterruptedException
if the current thread is not a
member of a ForkJoinPool and was interrupted while waitingjava.util.concurrent.TimeoutException
if the wait timed outfork
. 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)
.
null
if noneinForkJoinPool()
true
if the current thread is a ForkJoinWorkerThread
executing as a ForkJoinPool computation.
true
if the current thread is a ForkJoinWorkerThread
executing as a ForkJoinPool computation,
or false
otherwisetrue
if unforkedjoin()
, 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.
null
if not completedtrue
if this task is known to have completed normallynull
if none are availablenull
if none are availablenull
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.
null
if none are availableif (task.compareAndSetForkJoinTaskTag((short)0, (short)1))
before processing, otherwise exiting because the node has
already been visited.
e
the expected tag valuetag
the new tag valueForkJoinTask
that performs the run
method of the given Runnable
as its action, and returns
a null result upon join()
.
runnable
the runnable actionForkJoinTask
that performs the run
method of the given Runnable
as its action, and returns
the given result upon join()
.
runnable
the runnable actionresult
the result upon completionForkJoinTask
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
.
callable
the callable action