ForkJoinTask (Java Platform SE 8 )

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

All Implemented Interfaces:

Serializable， Future

已知直接子类：

CountedCompleter， RecursiveAction， RecursiveTask
```
public abstract class ForkJoinTask<V>
extends Object
implements Future<V>, Serializable
```
对于运行在一个 ForkJoinPool任务抽象基类。一个 ForkJoinTask是线状实体，比普通螺纹重量更轻。大量的任务和子任务可以通过少量ForkJoinPool实际线程托管，在一些使用限制价格。
一个“主”ForkJoinTask开始时，它是明确地向ForkJoinPool，或执行，如果不是已经从事forkjoin计算，开始在ForkJoinPool.commonPool()通过fork()，invoke()，或相关的方法。一旦开始，它通常会依次启动其他任务。通过这个类的名称表示，许多程序使用ForkJoinTask使用方法fork()和join()，或其衍生物如invokeAll。然而，这个类还提供了一些其他的方法，可以发挥在先进的用途，以及扩展机制，允许支持新形式的叉/连接处理。

一个ForkJoinTask是一个轻量级的形式Future。对ForkJoinTasks效率源于一组限制（这只是部分静态强制执行）反映其作为计算任务计算纯函数或纯粹的孤立对象运行的主要用途。主要的协调机制fork()，安排异步执行，而不进行join()，直到任务的结果已经计算。计算应该避免synchronized方法或块，应尽量减少其他阻塞同步除了加入其他任务或使用同步移相器，如广告用叉子/合作加盟计划。细分任务也不应该执行阻塞I/O访问，应该是完全独立于其他任务运行访问变量。这些准则是不允许检查异常如IOExceptions被严格执行。然而，计算可能仍然遇到unchecked异常，是抛出给呼叫者试图加入他们。这些异常可能还包括来自内部资源枯竭RejectedExecutionException，如未能分配内部任务队列。重抛出异常的行为相同的方式作为规则的例外，但是，在可能的情况下，包含堆栈跟踪（如显示例如使用ex.printStackTrace()）两线程启动计算以及线程实际上遇到例外；最小的只有后者。

可以定义和使用forkjointasks可能阻塞，但这样做需要三个进一步的思考：（1）完成几个如果任何其他任务必须在任务依赖外部同步块或I / O事件式异步任务，没有加入（例如，那些子CountedCompleter）常常陷入这类。（2）以尽量减少资源的影响，任务应该是小的；理想情况下只执行（可能）阻塞行动。（3）除非ForkJoinPool.ManagedBlocker API的使用，或者一些可能阻塞的任务是低于游泳池的池ForkJoinPool.getParallelism()水平，不能保证足够的线程将可确保进度或性能好。

等待并完成一个任务的结果是join()提取的主要方法，但有几个变种：的Future.get()方法支持中断和/或定时等待使用Future约定竣工报告结果。方法invoke()语义等同fork(); join()但总是试图在当前线程开始执行。这些方法的“安静”形式不提取结果或报告的异常。当一组任务被执行时，这些可能是有用的，你需要延迟处理的结果或异常，直到所有完成。方法invokeAll（多个版本）执行并行调用的最常见形式：分叉的一组任务和加入他们。

在最典型的用法中，一个叉连接像一个调用（叉）和返回（连接）从一个并行的递归函数。作为与其他形式的递归调用的情况下，返回（连接）应首先执行最内部的。例如，a.fork(); b.fork(); b.join(); a.join();可能比加入前a b更有效。

任务的执行状态可以在几个层次上的细节isDone()查询：如果一个任务完成后（包括以任何方式的情况下，一个任务被取消而不执行）；isCompletedNormally()如果没有取消或遇到异常完成任务；isCancelled()如果任务被取消了（在这种情况下，getException()返回一个CancellationException）；和isCompletedAbnormally()是真的如果一个任务被取消或遇到一个例外，在这种情况下，getException()将返回遇到异常或CancellationException。

的forkjointask类通常不是直接继承。相反，你的子类之一，支持一个特定的风格的fork/join处理抽象类，通常RecursiveAction大多数计算不返回结果，而这样做的RecursiveTask，和那些在这CountedCompleter完成动作触发其他操作。通常，一个具体的forkjointask类声明其参数字段，构造函数中的建立，然后定义了一个方法，利用这compute基类提供的控制方法。

方法join()及其变种适用只有当完成依赖环；即，并行计算可以被描述为一个有向无环图（DAG）。否则，执行中可能遇到的一种死锁循环互相等待任务。然而，该框架支持的其他方法和技术（例如Phaser，helpQuiesce()，使用和complete(V)），可以使用在不静态结构化DAGs问题定制子类构造。为了支持这种用法，ForkJoinTask会被自动标记使用setForkJoinTaskTag(short)或compareAndSetForkJoinTaskTag(short, short) short值检查使用getForkJoinTaskTag()。的forkjointask实现不使用这些protected方法或标签的任何目的，但他们可能会使用专门的子类的构造。例如，可以使用提供的并行图遍历的方法来避免重复节点/任务已经加工。（用于标记的方法名称是笨重的，在一部分，以鼓励反映他们的使用模式的方法的定义。）

最基础的支护方法final，防止重要的实现，本质上是依赖于底层的轻量级任务调度框架。创建新的基本风格叉/开发者加入处理应至少实现protected方法exec()，setRawResult(V)，和getRawResult()，同时还引入一个抽象的计算方法，可以在子类中实现，可能依靠这类提供的其他protected方法。

forkjointasks应该执行的计算量相对较小。大的任务应该分成小任务，通常是通过递归分解。作为一个很粗略的规则，一个任务要执行超过100和低于10000的基本计算步骤，并应避免无限循环。如果任务太大，则并行不能提高吞吐量。如果太小，那么内存和内部任务维护开销可能会压倒处理。

这个类提供了Runnable和Callable adapt方法，可以用在其他种类的任务ForkJoinTasks混合执行。当所有的任务都是这种形式，考虑使用一个构建在asyncmode池。

forkjointasks是Serializable，这使它们可用于扩展功能如远程执行框架。它是将任务之前或之后，明智的，但不中，执行。在执行过程中，序列化是不依赖于的。

从以下版本开始：

一点七

另请参见：

Serialized Form

构造方法摘要

构造方法

Constructor and Description

ForkJoinTask()

构造方法
Constructor and Description
`ForkJoinTask()`

方法摘要

所有方法静态方法接口方法抽象方法具体的方法
Modifier and Type	Method and Description
`static <T> ForkJoinTask<T>`	`adapt(Callable<? extends T> callable)` 返回一个新的 `ForkJoinTask`执行给定的 `Callable`的 `call`方法作为其行动，并返回它的结果在 `join()`，翻译成 `RuntimeException`遇到任何检查异常。
`static ForkJoinTask<?>`	`adapt(Runnable runnable)` 返回一个新的 `ForkJoinTask`执行给定的 `Runnable`的 `run`方法作为其行动，并返回空结果在 `join()`。
`static <T> ForkJoinTask<T>`	`adapt(Runnable runnable, T result)` 返回一个新的 `ForkJoinTask`执行给定的 `Runnable`的 `run`方法作为其行动，并返回给定的结果在 `join()`。
`boolean`	`cancel(boolean mayInterruptIfRunning)` 试图取消此任务的执行。
`boolean`	`compareAndSetForkJoinTaskTag(short e, short tag)` 原子条件设置此任务标签值。
`void`	`complete(V value)` 完成这一任务，如果不是已经中止或取消，返回给定值作为后续调用 `join`结果及相关操作。
`void`	`completeExceptionally(Throwable ex)` 完成这一任务异常，如果不是已经中止或取消，导致它把给定异常在 `join`及相关操作。
`protected abstract boolean`	`exec()` 立即执行此任务的基本动作，并返回真正的，如果从这个方法返回后，这个任务是保证正常完成。
`ForkJoinTask<V>`	`fork()` 安排在游泳池的当前任务正在运行，如果适用异步地执行这项任务，或使用 `ForkJoinPool.commonPool()`如果不 `inForkJoinPool()`。
`V`	`get()` 等待，如果需要计算完成，然后检索其结果。
`V`	`get(long timeout, TimeUnit unit)` 如果需要的话，在大多数给定的计算时间完成，然后检索其结果，如果可用。
`Throwable`	`getException()` 返回由基础计算引发的异常，或 `CancellationException`如果取消，或 `null`如果没有或如果方法尚未完成。
`short`	`getForkJoinTaskTag()` 返回此任务的标记。
`static ForkJoinPool`	`getPool()` 返回当前任务执行托管池，或null，如果这项任务执行的任何forkjoinpool外。
`static int`	`getQueuedTaskCount()` 返回，已分叉由当前线程但尚未执行的任务数的估计。
`abstract V`	`getRawResult()` 返回的结果将返回 `join()`，即使这个任务完成情况异常，或 `null`如果这项任务没有被完成。
`static int`	`getSurplusQueuedTaskCount()` 返回一个估计有多少本地排队任务由当前线程比有其他线程可能会偷它们，或零，如果线程不是ForkJoinPool操作。
`static void`	`helpQuiesce()` 可能执行的任务，直到主机当前的任务 `is quiescent`池。
`static boolean`	`inForkJoinPool()` 返回 `true`如果当前线程是执行计算 `ForkJoinWorkerThread` ForkJoinPool。
`V`	`invoke()` 开始执行这项任务，等待它的完成，如果有必要，并返回它的结果，或抛出一个（没有）如果底层的计算也 `RuntimeException`或 `Error`。
`static <T extends ForkJoinTask<?>> Collection<T>`	`invokeAll(Collection<T> tasks)` 福克斯所有任务在指定的集合中，返回时 `isDone`持有每个任务或（没有）遇到例外的是，在这种情况下会被重新抛出异常。
`static void`	`invokeAll(ForkJoinTask<?>... tasks)` 给定任务的叉子，返回时 `isDone`持有每个任务或（没有）遇到例外的是，在这种情况下会被重新抛出异常。
`static void`	`invokeAll(ForkJoinTask<?> t1, ForkJoinTask<?> t2)` 给定任务的叉子，返回时 `isDone`持有每个任务或（没有）遇到例外的是，在这种情况下会被重新抛出异常。
`boolean`	`isCancelled()` 返回 `true`如果这个任务完成之前取消正常。
`boolean`	`isCompletedAbnormally()` 如果这个任务返回 `true`抛出一个异常或被取消。
`boolean`	`isCompletedNormally()` 返回 `true`如果完成这个任务不抛出异常，并没有取消。
`boolean`	`isDone()` 返回 `true`如果完成这个任务。
`V`	`join()` 返回计算的结果时，它 `is done`。
`protected static ForkJoinTask<?>`	`peekNextLocalTask()` 返回，但不取消预定或执行任务队列的当前线程，但尚未执行，如果是立即可用。
`protected static ForkJoinTask<?>`	`pollNextLocalTask()` unschedules和回报，而不执行，下一个任务队列的当前线程，但尚未执行，如果当前线程是ForkJoinPool操作。
`protected static ForkJoinTask<?>`	`pollTask()` 如果当前线程是ForkJoinPool操作，unschedules和回报，而不执行，下一个任务队列的当前线程，但尚未执行，如果有可用的，或者如果没有，那是分叉的其它线程的任务，如果可以的话。
`void`	`quietlyComplete()` 在不设置值的情况下正常地完成此任务。
`void`	`quietlyInvoke()` 开始执行这项任务，等待它的完成，如果有必要，但不返回结果或投掷例外。
`void`	`quietlyJoin()` 加入这个任务，而不返回其结果或抛出它的异常。
`void`	`reinitialize()` 重置此任务的内部记账的状态，让后续的 `fork`。
`short`	`setForkJoinTaskTag(short tag)` 自动设置此任务的标签值。
`protected abstract void`	`setRawResult(V value)` 强制将给定的值作为结果返回。
`boolean`	`tryUnfork()` 试图取消预定的任务执行。

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ForkJoinTask
```
public ForkJoinTask()
```
- 方法详细信息
  - fork
```
public final ForkJoinTask<V> fork()
```
    安排在游泳池的当前任务正在运行，如果适用异步地执行这项任务，或使用 ForkJoinPool.commonPool()如果不 inForkJoinPool()。虽然不一定执行，这是一个使用错误叉任务不止一次，除非它已完成并被重新初始化。这项任务的状态或数据，它在随后的修改不一定持续观察其他比一个执行除非之前被调用的方法 join()或相关的任何线程，或者打个电话 isDone()返回 true。
    
    结果
    
    this，简化的使用
  - join
```
public final V join()
```
    返回计算的结果时，它 is done。这种方法不同于在正常完成结果在 RuntimeException或 Error， get()不 ExecutionException，和中断调用线程不导致方法投掷 InterruptedException突然回来。
    
    结果
    
    计算结果
  - invoke
```
public final V invoke()
```
    开始执行这项任务，等待它的完成，如果有必要，并返回它的结果，或抛出一个（没有）如果底层的计算也 RuntimeException或 Error。
    
    结果
    
    计算结果
  - invokeAll
```
public static void invokeAll(ForkJoinTask<?> t1,
                             ForkJoinTask<?> t2)
```
    给定任务的叉子，返回时 isDone持有每个任务或（没有）遇到例外的是，在这种情况下会被重新抛出异常。如果一个以上的任务遇到异常，则此方法将抛出任何一个异常。如果任何任务遇到异常，另一个可能被取消。然而，个别任务的执行状态是不保证在特殊的回报。每个任务的状态可以用 getException()和相关的方法来检查他们是否已经取消，完成正常或异常，或离开未处理。
    
    参数
    
    t1 -第一个任务
    
    t2 -第二任务
    
    异常
    
    NullPointerException -如果任何任务是空的
  - invokeAll
```
public static void invokeAll(ForkJoinTask<?>... tasks)
```
    给定任务的叉子，返回时 isDone持有每个任务或（没有）遇到例外的是，在这种情况下会被重新抛出异常。如果一个以上的任务遇到异常，则此方法将抛出任何一个异常。如果任何任务遇到异常，其他的可能被取消。然而，个别任务的执行状态是不保证在特殊的回报。每个任务的状态可以用 getException()和相关的方法来检查他们是否已经取消，完成正常或异常，或离开未处理。
    
    参数
    
    tasks -任务
    
    异常
    
    NullPointerException -如果任何任务是空的
  - invokeAll
```
public static <T extends ForkJoinTask<?>> Collection<T> invokeAll(Collection<T> tasks)
```
    福克斯所有任务在指定的集合中，返回时 isDone持有每个任务或（没有）遇到例外的是，在这种情况下会被重新抛出异常。如果一个以上的任务遇到异常，则此方法将抛出任何一个异常。如果任何任务遇到异常，其他的可能被取消。然而，个别任务的执行状态是不保证在特殊的回报。每个任务的状态可以用 getException()和相关的方法来检查他们是否已经取消，完成正常或异常，或离开未处理。
    
    参数类型
    
    T -值的类型从任务返回
    
    参数
    
    tasks -任务的集合
    
    结果
    
    任务参数，以简化使用
    
    异常
    
    NullPointerException如果任务或任何元素都是空的
  - cancel
```
public boolean cancel(boolean mayInterruptIfRunning)
```
    试图取消此任务的执行。如果任务已经完成或不能以其他原因取消，这种尝试将失败。如果成功的话，这方面的工作还没有开始的时候， cancel称，这个任务执行的抑制。此方法返回后成功，除非有 reinitialize()中介电话，随后调用 isCancelled()， isDone()，和 cancel将返回 true和调用 join()和相关方法将导致 CancellationException
    这种方法可以在子类中重写，但即便如此，还必须确保这些属性保存。特别是，该cancel方法本身不能抛出异常。
    
    这种方法被设计为通过其他任务调用。终止当前的任务，你可以返回或抛出unchecked异常的计算方法，或者调用completeExceptionally(Throwable)。
    。
    
    Specified by:
    
    cancel 接口 Future<V>
    
    参数
    
    mayInterruptIfRunning -这个值没有影响，因为在默认实现中断并不是用来控制消除。
    
    结果
    
    true如果这个任务被取消
  - isDone
```
public final boolean isDone()
```
    从接口复制的描述： Future
    
    返回 true如果完成这个任务。完成可能是由于正常终止，例外，或取消——在所有这些情况下，此方法将返回 true。
    
    Specified by:
    
    isDone 接口 Future<V>
    
    结果
    
    true如果完成这个任务
  - isCancelled
```
public final boolean isCancelled()
```
    从接口复制的描述： Future
    
    返回 true如果这个任务完成之前取消正常。
    
    Specified by:
    
    isCancelled 接口 Future<V>
    
    结果
    
    true如果这个任务完成之前取消
  - isCompletedAbnormally
```
public final boolean isCompletedAbnormally()
```
    如果这个任务返回 true抛出一个异常或被取消。
    
    结果
    
    如果这个任务 true抛出一个异常或被取消
  - isCompletedNormally
```
public final boolean isCompletedNormally()
```
    返回 true如果完成这个任务不抛出异常，并没有取消。
    
    结果
    
    true如果完成这个任务不抛出异常，并没有取消
  - getException
```
public final Throwable getException()
```
    返回由基础计算引发的异常，或 CancellationException如果取消，或 null如果没有或如果方法尚未完成。
    
    结果
    
    如果没有例外，或 null
  - completeExceptionally
```
public void completeExceptionally(Throwable ex)
```
    完成这一任务异常，如果不是已经中止或取消，导致它把给定异常在 join及相关操作。此方法可用于诱导异步任务中的异常，或强制完成未完成的任务的完成。它在其他情况下的使用是不鼓励的。这种方法是重写，但重写的版本必须调用 super实现维持担保。
    
    参数
    
    ex -抛出异常。如果这个例外是不是 RuntimeException或 Error，实际抛出的异常将导致 ex RuntimeException。
  - complete
```
public void complete(V value)
```
    完成这一任务，如果不是已经中止或取消，返回给定值作为后续调用 join结果及相关操作。此方法可用于为异步任务提供结果，或为无法正常完成的任务提供可选择的处理方法。它在其他情况下的使用是不鼓励的。这种方法是重写，但重写的版本必须调用 super实现维持担保。
    
    参数
    
    value -此任务的结果值
  - quietlyComplete
```
public final void quietlyComplete()
```
    在不设置值的情况下正常地完成此任务。建立了 setRawResult(V)最新值（或 null默认）将返回为后续调用 join结果及相关操作。
    
    从以下版本开始：
    
    一点八
  - get
```
public final V get()
            throws InterruptedException,
                   ExecutionException
```
    等待，如果需要计算完成，然后检索其结果。
    
    Specified by:
    
    get 接口 Future<V>
    
    结果
    
    计算结果
    
    异常
    
    CancellationException如果计算被取消
    
    ExecutionException如果计算抛出一个异常
    
    InterruptedException -如果当前线程不是ForkJoinPool成员和被中断的等待
  - get
```
public final V get(long timeout,
                   TimeUnit unit)
            throws InterruptedException,
                   ExecutionException,
                   TimeoutException
```
    如果需要的话，在大多数给定的计算时间完成，然后检索其结果，如果可用。
    
    Specified by:
    
    get 接口 Future<V>
    
    参数
    
    timeout -最大等待时间
    
    unit - timeout参数的时间单位
    
    结果
    
    计算结果
    
    异常
    
    CancellationException如果计算被取消
    
    ExecutionException如果计算抛出一个异常
    
    InterruptedException -如果当前线程不是ForkJoinPool成员和被中断的等待
    
    TimeoutException如果等待超时
  - quietlyJoin
```
public final void quietlyJoin()
```
    加入这个任务，而不返回其结果或抛出它的异常。此方法可能是有用的，当处理集合的任务时，一些已被取消或以其他方式已中止。
  - quietlyInvoke
```
public final void quietlyInvoke()
```
    开始执行这项任务，等待它的完成，如果有必要，但不返回结果或投掷例外。
  - helpQuiesce
```
public static void helpQuiesce()
```
    可能执行的任务，直到主机当前的任务 is quiescent池。这种方法可以使用在设计中，许多任务都是分叉的，但没有明确的加入，而不是执行它们直到全部处理。
  - reinitialize
```
public void reinitialize()
```
    重置此任务的内部记账的状态，让后续的 fork。这种方法可以重复此任务的重用，但重用时，这个任务有没有被分叉，或是分叉的，然后完成这项任务所有优秀的加入也完成了。任何其他使用条件下的影响都不能保证。这种方法可能是有用的在执行预先构建的树中的子任务的循环。
    在本方法完成，isDone()报道false，和getException()报道null。然而，返回的值是不受影响的getRawResult。清除此值，您可以调用setRawResult(null)。
  - getPool
```
public static ForkJoinPool getPool()
```
    返回当前任务执行托管池，或null，如果这项任务执行的任何forkjoinpool外。
    
    结果
    
    如果没有游泳池，或 null
    
    另请参见：
    
    inForkJoinPool()
  - inForkJoinPool
```
public static boolean inForkJoinPool()
```
    返回 true如果当前线程是执行计算 ForkJoinWorkerThread ForkJoinPool。
    
    结果
    
    true如果当前线程是一个执行 ForkJoinWorkerThread ForkJoinPool计算，或 false否则
  - tryUnfork
```
public boolean tryUnfork()
```
    试图取消预定的任务执行。这种方法通常（但不保证）如果这项任务最近分叉的任务由当前线程成功，还没有开始在另一个线程执行。这种方法可能是有用的，当安排替代本地处理的任务，可能是，但不是，被盗。
    
    结果
    
    true如果没有分叉
  - getQueuedTaskCount
```
public static int getQueuedTaskCount()
```
    返回，已分叉由当前线程但尚未执行的任务数的估计。此值可能是有用的启发式决策是否叉其他任务。
    
    结果
    
    任务数量
  - getSurplusQueuedTaskCount
```
public static int getSurplusQueuedTaskCount()
```
    返回一个估计有多少本地排队任务由当前线程比有其他线程可能会偷它们，或零，如果线程不是ForkJoinPool操作。此值可能是有用的启发式决策是否叉其他任务。在forkjointasks多种用途，在稳定状态下，每个工人都应该保持一个很小的常数剩余（例如，3）的任务，并处理局部计算如果超过阈值。
    
    结果
    
    剩余数量的任务，这可能是否定的
  - getRawResult
```
public abstract V getRawResult()
```
    返回的结果将返回 join()，即使这个任务完成情况异常，或 null如果这项任务没有被完成。这种方法的设计，以帮助调试，以及支持扩展。它在任何其他上下文中的使用是气馁的。
    
    结果
    
    结果，或 null如果没有完成
  - setRawResult
```
protected abstract void setRawResult(V value)
```
    强制将给定的值作为结果返回。这种方法的目的是支持扩展，而不应该在一般被称为其他方法。
    
    参数
    
    value -价值
  - exec
```
protected abstract boolean exec()
```
    立即执行此任务的基本动作，并返回真正的，如果从这个方法返回后，这个任务是保证正常完成。该方法返回false，否则，表明这项任务是不完整的（或是不完整的），例如在异步操作完成，需要显式调用的方法。此方法还可以抛出一个（未检查的）异常来指示异常退出。这种方法的目的是支持扩展，而不应该在一般被称为其他方法。
    
    结果
    
    true如果这个任务已经完成正常
  - peekNextLocalTask
```
protected static ForkJoinTask<?> peekNextLocalTask()
```
    返回，但不取消预定或执行任务队列的当前线程，但尚未执行，如果是立即可用。没有保证，这项任务将实际进行调查或执行下一步。相反，这种方法可以返回空，即使一个任务存在，但不能访问，没有与其他线程的争。这种方法的设计主要是支持扩展，而不可能是有用的，否则。
    
    结果
    
    下一个任务，或 null如果没有可用的
  - pollNextLocalTask
```
protected static ForkJoinTask<?> pollNextLocalTask()
```
    unschedules和回报，而不执行，下一个任务队列的当前线程，但尚未执行，如果当前线程是ForkJoinPool操作。这种方法的设计主要是支持扩展，而不可能是有用的，否则。
    
    结果
    
    下一个任务，或 null如果没有可用的
  - pollTask
```
protected static ForkJoinTask<?> pollTask()
```
    如果当前线程是ForkJoinPool操作，unschedules和回报，而不执行，下一个任务队列的当前线程，但尚未执行，如果有可用的，或者如果没有，那是分叉的其它线程的任务，如果可以的话。可用性可能是短暂的，所以 null结果并不一定意味着游泳池的平静是在任务操作。这种方法的设计主要是支持扩展，而不可能是有用的，否则。
    
    结果
    
    一个任务，或 null如果没有可用的
  - getForkJoinTaskTag
```
public final short getForkJoinTaskTag()
```
    返回此任务的标记。
    
    结果
    
    此任务的标记
    
    从以下版本开始：
    
    一点八
  - setForkJoinTaskTag
```
public final short setForkJoinTaskTag(short tag)
```
    自动设置此任务的标签值。
    
    参数
    
    tag -标签值
    
    结果
    
    标签的前一个值
    
    从以下版本开始：
    
    一点八
  - compareAndSetForkJoinTaskTag
```
public final boolean compareAndSetForkJoinTaskTag(short e,
                                                  short tag)
```
    原子条件设置此任务标签值。在其他的一些应用中，标签可以作为任务图上操作的访问标记，如方法检查： if (task.compareAndSetForkJoinTaskTag((short)0, (short)1))之前处理，否则退出由于节点已经被访问了。
    
    参数
    
    e -预期的标签值
    
    tag -新的标签值
    
    结果
    
    true如果成功；即，当前值等于E和现在的标签。
    
    从以下版本开始：
    
    一点八
  - adapt
```
public static ForkJoinTask<?> adapt(Runnable runnable)
```
    返回一个新的 ForkJoinTask执行给定的 Runnable的 run方法作为其行动，并返回空结果在 join()。
    
    参数
    
    runnable -运行动作
    
    结果
    
    任务
  - adapt
```
public static <T> ForkJoinTask<T> adapt(Runnable runnable,
                                        T result)
```
    返回一个新的 ForkJoinTask执行给定的 Runnable的 run方法作为其行动，并返回给定的结果在 join()。
    
    参数类型
    
    T -结果的类型
    
    参数
    
    runnable -运行动作
    
    result结果完成后
    
    结果
    
    任务
  - adapt
```
public static <T> ForkJoinTask<T> adapt(Callable<? extends T> callable)
```
    返回一个新的 ForkJoinTask执行给定的 Callable的 call方法作为其行动，并返回它的结果在 join()，翻译成 RuntimeException遇到任何检查异常。
    
    参数类型
    
    T -可调用的结果的类型
    
    参数
    
    callable的赎回行动
    
    结果
    
    任务

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class ForkJoinTask<V>

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

Constructor Detail

ForkJoinTask

方法详细信息

fork

join

invoke

invokeAll

invokeAll

invokeAll

cancel

isDone

isCancelled

isCompletedAbnormally

isCompletedNormally

getException

completeExceptionally

complete

quietlyComplete

get

get

quietlyJoin

quietlyInvoke

helpQuiesce

reinitialize

getPool

inForkJoinPool

tryUnfork

getQueuedTaskCount

getSurplusQueuedTaskCount

getRawResult

setRawResult

exec

peekNextLocalTask

pollNextLocalTask

pollTask

getForkJoinTaskTag

setForkJoinTaskTag

compareAndSetForkJoinTaskTag

adapt

adapt

adapt