abstract class ForkJoinTask[V] extends Future[V] with Serializable
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 it is
explicitly submitted to a ForkJoinPool
, or, if not already
engaged in a ForkJoin computation, commenced in the ForkJoinPool#commonPool()
via #fork
, #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 #fork
and
#join
, or derivatives such as #invokeAll(ForkJoinTask...) invokeAll
. However, this class also
provides a number of other methods that can come into play in
advanced usages, as well as extension mechanics that allow support
of new forms of fork/join processing.
A ForkJoinTask
is a lightweight form of Future
.
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 #fork
, that arranges
asynchronous execution, and #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 RejectedExecutionException
stemming from internal resource
exhaustion, such as failure to allocate internal task
queues. Rethrown exceptions behave in the same way as regular
exceptions, but, when possible, contain stack traces (as displayed
for example using 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 CountedCompleter
) often fall into this category. (2) To minimize
resource impact, tasks should be small; ideally performing only the
(possibly) blocking action. (3) Unless the ForkJoinPool.ManagedBlocker
API is used, or the number of possibly
blocked tasks is known to be less than the pool's ForkJoinPool#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 #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 #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: #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 java.util.concurrent.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
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 RecursiveAction
for most computations that do not return results,
RecursiveTask
for those that do, and CountedCompleter
for those in which completed actions trigger
other actions. Normally, a concrete ForkJoinTask subclass declares
fields comprising its parameters, established in a constructor, and
then defines a compute
method that somehow uses the control
methods supplied by this base class.
Method #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
Phaser
, #helpQuiesce
, and #complete
) that
may be of use in constructing custom subclasses for problems that
are not statically structured as DAGs. To support such usages a
ForkJoinTask may be atomically tagged with a short
value using #setForkJoinTaskTag
or #compareAndSetForkJoinTaskTag
and checked using #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 #exec
, #setRawResult
, 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, 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 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 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.
- Source
- ForkJoinTask.java
- Since
1.7
- Alphabetic
- By Inheritance
- ForkJoinTask
- Serializable
- Future
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Instance Constructors
- new ForkJoinTask()
Abstract Value Members
-
abstract
def
exec(): Boolean
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.
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
- Attributes
- protected[akka.dispatch.forkjoin]
-
abstract
def
getRawResult(): V
Returns the result that would be returned by
#join
, even if this task completed abnormally, ornull
if this task is not known to have been completed.Returns the result that would be returned by
#join
, even if this task completed abnormally, ornull
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
-
abstract
def
setRawResult(value: V): Unit
Forces the given value to be returned as a result.
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.
- value
the value
- Attributes
- protected[akka.dispatch.forkjoin]
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
+(other: String): String
- Implicit
- This member is added by an implicit conversion from ForkJoinTask[V] to any2stringadd[ForkJoinTask[V]] performed by method any2stringadd in scala.Predef.
- Definition Classes
- any2stringadd
-
def
->[B](y: B): (ForkJoinTask[V], B)
- Implicit
- This member is added by an implicit conversion from ForkJoinTask[V] to ArrowAssoc[ForkJoinTask[V]] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @inline()
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
cancel(mayInterruptIfRunning: Boolean): Boolean
Attempts to cancel execution of this task.
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#reinitialize
, subsequent calls to#isCancelled
,#isDone
, andcancel
will returntrue
and calls to#join
and related methods will result inCancellationException
.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
.- 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
- Definition Classes
- ForkJoinTask → Future
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate() @throws( ... )
-
final
def
compareAndSetForkJoinTaskTag(e: Short, tag: Short): Boolean
Atomically conditionally sets the tag value for this task.
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.- e
the expected tag value
- tag
the new tag value
- returns
true if successful; i.e., the current value was equal to e and is now tag.
- Since
1.8
-
def
complete(value: V): Unit
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.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 invokesuper
implementation to maintain guarantees.- value
the result value for this task
-
def
completeExceptionally(ex: Throwable): Unit
Completes this task abnormally, and if not already aborted or cancelled, causes it to throw the given exception upon
join
and related operations.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 invokesuper
implementation to maintain guarantees.- ex
the exception to throw. If this exception is not a
RuntimeException
orError
, the actual exception thrown will be aRuntimeException
with causeex
.
-
def
ensuring(cond: (ForkJoinTask[V]) ⇒ Boolean, msg: ⇒ Any): ForkJoinTask[V]
- Implicit
- This member is added by an implicit conversion from ForkJoinTask[V] to Ensuring[ForkJoinTask[V]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
def
ensuring(cond: (ForkJoinTask[V]) ⇒ Boolean): ForkJoinTask[V]
- Implicit
- This member is added by an implicit conversion from ForkJoinTask[V] to Ensuring[ForkJoinTask[V]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
def
ensuring(cond: Boolean, msg: ⇒ Any): ForkJoinTask[V]
- Implicit
- This member is added by an implicit conversion from ForkJoinTask[V] to Ensuring[ForkJoinTask[V]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
def
ensuring(cond: Boolean): ForkJoinTask[V]
- Implicit
- This member is added by an implicit conversion from ForkJoinTask[V] to Ensuring[ForkJoinTask[V]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
fork(): ForkJoinTask[V]
Arranges to asynchronously execute this task in the pool the current task is running in, if applicable, or using the
ForkJoinPool#commonPool()
if not#inForkJoinPool
.Arranges to asynchronously execute this task in the pool the current task is running in, if applicable, or using the
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
returningtrue
.- returns
this
, to simplify usage
-
def
formatted(fmtstr: String): String
- Implicit
- This member is added by an implicit conversion from ForkJoinTask[V] to StringFormat[ForkJoinTask[V]] performed by method StringFormat in scala.Predef.
- Definition Classes
- StringFormat
- Annotations
- @inline()
-
final
def
get(timeout: Long, unit: TimeUnit): V
Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available.
Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available.
- timeout
the maximum time to wait
- unit
the time unit of the timeout argument
- returns
the computed result
- Definition Classes
- ForkJoinTask → Future
- Exceptions thrown
CancellationException
if the computation was cancelledExecutionException
if the computation threw an exceptionInterruptedException
if the current thread is not a member of a ForkJoinPool and was interrupted while waitingTimeoutException
if the wait timed out
-
final
def
get(): V
Waits if necessary for the computation to complete, and then retrieves its result.
Waits if necessary for the computation to complete, and then retrieves its result.
- returns
the computed result
- Definition Classes
- ForkJoinTask → Future
- Exceptions thrown
CancellationException
if the computation was cancelledExecutionException
if the computation threw an exceptionInterruptedException
if the current thread is not a member of a ForkJoinPool and was interrupted while waiting
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
final
def
getException(): Throwable
Returns the exception thrown by the base computation, or a
CancellationException
if cancelled, ornull
if none or if the method has not yet completed.Returns the exception thrown by the base computation, or a
CancellationException
if cancelled, ornull
if none or if the method has not yet completed.- returns
the exception, or
null
if none
-
final
def
getForkJoinTaskTag(): Short
Returns the tag for this task.
Returns the tag for this task.
- returns
the tag for this task
- Since
1.8
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
final
def
invoke(): V
Commences performing this task, awaits its completion if necessary, and returns its result, or throws an (unchecked)
RuntimeException
orError
if the underlying computation did so.Commences performing this task, awaits its completion if necessary, and returns its result, or throws an (unchecked)
RuntimeException
orError
if the underlying computation did so.- returns
the computed result
-
final
def
isCancelled(): Boolean
- Definition Classes
- ForkJoinTask → Future
-
final
def
isCompletedAbnormally(): Boolean
Returns
true
if this task threw an exception or was cancelled.Returns
true
if this task threw an exception or was cancelled.- returns
true
if this task threw an exception or was cancelled
-
final
def
isCompletedNormally(): Boolean
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.- returns
true
if this task completed without throwing an exception and was not cancelled
-
final
def
isDone(): Boolean
- Definition Classes
- ForkJoinTask → Future
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
join(): V
Returns the result of the computation when it
is done
.Returns the result of the computation when it
is done
. This method differs from#get()
in that abnormal completion results inRuntimeException
orError
, notExecutionException
, and that interrupts of the calling thread do not cause the method to abruptly return by throwingInterruptedException
.- returns
the computed result
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
final
def
quietlyComplete(): Unit
Completes this task normally without setting a value.
Completes this task normally without setting a value. The most recent value established by
#setRawResult
(ornull
by default) will be returned as the result of subsequent invocations ofjoin
and related operations.- Since
1.8
-
final
def
quietlyInvoke(): Unit
Commences performing this task and awaits its completion if necessary, without returning its result or throwing its exception.
-
final
def
quietlyJoin(): Unit
Joins this task, without returning its result or throwing its exception.
Joins this task, without returning its result or throwing its exception. This method may be useful when processing collections of tasks when some have been cancelled or otherwise known to have aborted.
-
def
reinitialize(): Unit
Resets the internal bookkeeping state of this task, allowing a subsequent
fork
.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()
reportsfalse
, andgetException()
reportsnull
. However, the value returned bygetRawResult
is unaffected. To clear this value, you can invokesetRawResult(null)
. -
final
def
setForkJoinTaskTag(tag: Short): Short
Atomically sets the tag value for this task.
Atomically sets the tag value for this task.
- tag
the tag value
- returns
the previous value of the tag
- Since
1.8
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
tryUnfork(): Boolean
Tries to unschedule this task for execution.
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
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
def
→[B](y: B): (ForkJoinTask[V], B)
- Implicit
- This member is added by an implicit conversion from ForkJoinTask[V] to ArrowAssoc[ForkJoinTask[V]] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc