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

All Implemented Interfaces:

Serializable ， Future<V>

已知直接子类：

CountedCompleter ， RecursiveAction ， RecursiveTask
```
public abstract class ForkJoinTask<V>
extends Object
implements Future<V>, Serializable
```
在ForkJoinPool内运行的任务的抽象基类。 A ForkJoinTask是一个线程实体，比正常线程重得多。大量任务和子任务可能由ForkJoinPool中的少量实际线程托管，价格为某些使用限制。
A“主” ForkJoinTask开始执行时，明确提出到ForkJoinPool ，或者，如果不是已经从事ForkJoin计算，在开始ForkJoinPool.commonPool()通过fork() ， invoke() ，或相关方法。一旦开始，它通常反过来启动其他子任务。如该类的名称所示，使用ForkJoinTask许多程序ForkJoinTask使用方法fork()和join() ，或衍生物，例如invokeAll 。然而，这个课程还提供了许多可以在高级用途中发挥作用的其他方法，以及允许支持新形式的叉/连接处理的扩展机制。

A ForkJoinTask是一个轻量级的形式Future 。 ForkJoinTask的效率源于一组限制（只有部分可静态执行），反映出它们主要用作计算纯函数或在纯孤立对象上运行的计算任务。主要的协调机制是fork() ，即安排异步执行，并join() ，不继续，直到任务的结果被计算出来。理想情况下，计算应避免使用synchronized方法或块，并应尽可能减少其他阻塞同步，除了加入其他任务，或者使用同步器，例如被广告与fork / join调度合作的激活器。可分割的任务也不应该执行阻塞I / O，理想情况下，访问完全独立于其他运行任务访问的变量。这些指南通过不允许抛出例如IOExceptions等检查异常来宽松地执行。但是，计算可能仍然会遇到未经检查的异常，这些异常被转移给尝试加入它们的呼叫者。这些例外可能还包括来自内部资源耗尽的RejectedExecutionException ，例如无法分配内部任务队列。 Rethrown异常的行为与常规异常的方式相同，但如果可能，则包含启动计算的线程以及实际遇到异常的线程的堆栈跟踪（例如使用ex.printStackTrace()显示）; 最低限度只有后者。

可以定义和使用可能会阻塞的ForkJoinTasks，但这样做需要三个进一步的考虑：（1）如果任何其他任务应该依赖于阻塞外部同步或I / O的任务，则完成很少。事件风格的异步任务从未加入（例如，这些子类CountedCompleter ）通常属于此类别。（2）尽量减少资源影响，任务要小; 理想地仅执行（可能）阻塞动作。（3）除非使用ForkJoinPool.ManagedBlocker API，否则已知可能已阻止的任务数量小于池的ForkJoinPool.getParallelism()级别，否则池不能保证有足够的线程可用于确保进度或性能良好。

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

在最典型的用法中，fork-join对就像一个调用（fork）并从并行递归函数返回（join）。与其他形式的递归调用一样，返回（连接）应该是最内层的。例如， a.fork(); b.fork(); b.join(); a.join();很可能是显着大于接合更有效a之前b 。

任务的执行状态可以在多个细节级别查询：如果任务以任何方式完成（包括任务被取消而不执行的情况），则为isDone() ; isCompletedNormally()如果任务在没有取消或遇到异常的情况下完成，则为true; isCancelled()如果任务被取消，则为true（在这种情况下， getException()返回一个CancellationException ）; 如果任务被取消或遇到异常，则isCompletedAbnormally()为true，在这种情况下， getException()将返回遇到的异常或CancellationException 。

ForkJoinTask类通常不是直接子类。相反，你继承了支持叉的特定风格/连接处理，通常是抽象类的一个RecursiveAction对于不返回结果大多数计算， RecursiveTask对于那些做的， CountedCompleter对于那些在已完成的操作触发其它动作。通常，具体的ForkJoinTask子类声明包含在构造函数中建立的参数的字段，然后定义一种以某种方式使用此基类提供的控制方法的compute方法。

方法join()及其变体仅在完成依赖关系为非循环时才适用; 也就是说，并行计算可以被描述为有向无环图（DAG）。否则，任务可能会遇到一种形式的死锁，因为任务周期性地等待对方。然而，该框架支持的其它方法和技术（例如使用Phaser ， helpQuiesce()和complete(V) ），其可以使用在构建定制子类为没有静态构造为DAG的问题。为了支持这种用途，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 ，它使它们可以用于扩展，如远程执行框架。仅在执行之前或之后序列化任务是明智的，而不是执行期间。序列化在执行本身时不依赖。

从以下版本开始：

1.7

另请参见：

Serialized Form

构造方法摘要

构造方法
Constructor	描述
`ForkJoinTask()`

方法摘要

所有方法静态方法接口方法抽象方法具体的方法
Modifier and Type	方法	描述
`static ForkJoinTask<?>`	`adapt(Runnable runnable)`	返回一个新的 `ForkJoinTask` ，它执行给定的 `Runnable`作为其操作的 `run`方法，并返回一个空值结果 `join()` 。
`static <T> ForkJoinTask<T>`	`adapt(Runnable runnable, T result)`	返回一个新的 `ForkJoinTask` ，它执行给定的 `Runnable`作为其操作的 `run`方法，并将给定结果返回到 `join()` 。
`static <T> ForkJoinTask<T>`	`adapt(Callable<? extends T> callable)`	返回一个新的 `ForkJoinTask` ，它执行给定的 `Callable`作为其操作的 `call`方法，并将其结果返回到 `join()` ，将遇到的任何检查的异常转换为 `RuntimeException` 。
`boolean`	`cancel(boolean mayInterruptIfRunning)`	尝试取消执行此任务。
`boolean`	`compareAndSetForkJoinTaskTag(short expect, short update)`	以原子方式有条件地设置此任务的标签值。
`void`	`complete(V value)`	完成此任务，如果尚未中止或取消，则返回给定值作为以后调用的结果 `join`和相关操作。
`void`	`completeExceptionally(Throwable ex)`	完成此任务异常，如果尚未中止或取消，将导致给定的异常在 `join`和相关操作。
`protected abstract boolean`	`exec()`	立即执行此任务的基本操作，并返回true，如果从此方法返回后，此任务将保证已正常完成。
`ForkJoinTask<V>`	`fork()`	安排在当前任务正在运行的池中异步执行此任务，如果适用，或使用 `ForkJoinPool.commonPool()`（如果不是 `inForkJoinPool()`）。
`V`	`get()`	等待计算完成，然后检索其结果。
`V`	`get(long timeout, TimeUnit unit)`	如果需要等待最多在给定的时间计算完成，然后检索其结果（如果可用）。
`Throwable`	`getException()`	返回由基本计算引发的异常，如果已取消，则 `null`如果没有，则返回 `CancellationException` ，或者方法尚未完成。
`short`	`getForkJoinTaskTag()`	返回此任务的标签。
`static ForkJoinPool`	`getPool()`	返回托管当前线程的池，如果当前线程在任何ForkJoinPool之外执行，则返回 `null` 。
`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()`	如果当前线程正在ForkJoinPool中运行，则不执行当前线程排队的下一个任务但尚未执行的时间并返回。
`protected static ForkJoinTask<?>`	`pollSubmission()`	如果当前线程在ForkJoinPool中运行，则不执行外部提交到池的任务（如果有的话）可以取消调度和返回。
`protected static ForkJoinTask<?>`	`pollTask()`	如果当前线程在ForkJoinPool中运行，则不执行下一个任务，返回当前线程排队的下一个任务，但尚未执行，如果一个可用，或者如果不可用，则由其他线程分派的任务，如果可供使用的话。
`void`	`quietlyComplete()`	正常完成此任务而不设置值。
`void`	`quietlyInvoke()`	执行此任务并等待其完成（如有必要），而不返回其结果或抛出异常。
`void`	`quietlyJoin()`	加入此任务，不返回其结果或抛出异常。
`void`	`reinitialize()`	重置此任务的内部簿记状态，允许随后的 `fork` 。
`short`	`setForkJoinTaskTag(short newValue)`	原子地设置此任务的标签值并返回旧值。
`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

- 构造方法详细信息
  - ForkJoinTask
```
public ForkJoinTask()
```
- 方法详细信息
  - fork
```
public final ForkJoinTask<V> fork()
```
    在当前任务正在运行的池中异步执行此任务，如果适用，或使用ForkJoinPool.commonPool()（如果不是inForkJoinPool()）。虽然它不一定执行，但是除非完成并重新初始化，否则任务多次分配是一种使用错误。对该任务的状态的后续修改或其操作的任何数据不一定被除了执行它之外的任何线程一致地观察到，除非先前通过呼叫join()或相关方法，或者呼叫isDone()返回true 。
    
    结果
    
    this ，以简化使用
  - join
```
public final V join()
```
    当它返回is done计算的结果。该方法与get()的不同之处在于，异常完成导致RuntimeException或Error ，而不是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适用于每个任务时返回，或遇到（未检查）异常，在这种情况下，将重新isDone异常。如果有多个任务遇到异常，则该方法会抛出任何一个异常。如果任何一个任务遇到异常，其他任务可能被取消。但是，单独任务的执行状态在特殊返回时不能得到保证。每个任务的状态可以使用getException()和相关方法来获取，以检查它们是否已被取消，正常完成或异常完成或未被处理。
    
    参数类型
    
    T - 从任务返回的值的类型
    
    参数
    
    tasks - 任务的收集
    
    结果
    
    任务参数，以简化使用
    
    异常
    
    NullPointerException - 如果任务或任何元素为空
  - cancel
```
public boolean cancel(boolean mayInterruptIfRunning)
```
    尝试取消执行此任务。如果任务已经完成或由于其他原因不能取消，则此尝试将失败。如果成功，并且当cancel时此任务尚未启动，则此任务的执行被抑制。此方法成功返回后，除非有中断呼叫reinitialize() ，否则后续拨打isCancelled(),isDone()和cancel将返回true并调用join()及相关方法将导致CancellationException 。
    此方法可能会在子类中被覆盖，但如果是这样，仍然必须确保这些属性成立。特别地， cancel方法本身不能抛出异常。
    
    该方法被设计为由其他任务调用。要终止当前任务，您只需从其计算方法返回或抛出未经检查的异常，或调用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()
```
    返回由基本计算引发的异常，如果已取消，则 null如果没有，则返回 CancellationException ，或者方法尚未完成。
    
    结果
    
    例外，如果没有， null
  - completeExceptionally
```
public void completeExceptionally(Throwable ex)
```
    完成此任务异常，如果尚未中止或取消，将导致给定的异常在join和相关操作。该方法可用于在异步任务中引发异常，或强制执行否则完成的任务。不鼓励在其他情况下使用它。此方法是可以覆盖的，但覆盖的版本必须调用super实现才能保证。
    
    参数
    
    ex - 抛出异常。如果这个异常不是RuntimeException或Error ，抛出的实际异常将是RuntimeException ，原因是ex 。
  - complete
```
public void complete(V value)
```
    完成此任务，如果尚未中止或取消，则返回给定值作为以后调用join和相关操作的结果。该方法可用于为异步任务提供结果，或为不能正常完成的任务提供替代处理。不鼓励在其他情况下使用它。此方法是可以覆盖的，但是覆盖版本必须调用super实现来维护保证。
    
    参数
    
    value - 此任务的结果值
  - quietlyComplete
```
public final void quietlyComplete()
```
    正常完成此任务而不设置值。 setRawResult(V) （或默认为null ）建立的最新值由于后续调用join和相关操作而返回。
    
    从以下版本开始：
    
    1.8
  - 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 - 超时参数的时间单位
    
    结果
    
    计算结果
    
    异常
    
    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()
```
    返回托管当前线程的池，如果当前线程在任何ForkJoinPool之外执行，则返回null 。
    该方法返回null当且仅当inForkJoinPool()个回报false 。
    
    结果
    
    池，或 null如果没有
  - inForkJoinPool
```
public static boolean inForkJoinPool()
```
    返回true如果当前线程是ForkJoinWorkerThread执行作为ForkJoinPool计算。
    
    结果
    
    true如果当前线程是作为ForkJoinPool计算执行的ForkJoinWorkerThread ，否则为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()
```
    立即执行此任务的基本操作，并返回true，如果从此方法返回后，此任务将保证已正常完成。否则，此方法可能返回false，以指示此任务未必完整（或不知道是完整的），例如在需要显式调用完成方法的异步操作中。此方法也可能引发（未检查）异常来指示异常退出。这种方法被设计为支持扩展，一般不应该以其他方式调用。
    
    结果
    
    true如果此任务已知已正常完成
  - peekNextLocalTask
```
protected static ForkJoinTask<?> peekNextLocalTask()
```
    返回，但不会取消调度或执行当前线程排队但尚未执行的任务（如果可以立即可用）。不能保证这个任务实际上将被接受查询或执行。相反，即使某个任务存在但是如果不与其他线程相争应，则该方法也可能返回null。这种方法主要是为了支持扩展，而且不太可能有用。
    
    结果
    
    下一个任务，或 null如果没有可用
  - pollNextLocalTask
```
protected static ForkJoinTask<?> pollNextLocalTask()
```
    如果当前线程正在ForkJoinPool中运行，则不执行当前线程排队的下一个任务但尚未执行的时间并返回。这种方法主要是为了支持扩展，而且不太可能有用。
    
    结果
    
    下一个任务，或 null如果没有可用
  - pollTask
```
protected static ForkJoinTask<?> pollTask()
```
    如果当前线程在ForkJoinPool中运行，则不执行下一个任务，返回当前线程排队的下一个任务，但尚未执行，如果一个可用，或者如果不可用，则由其他线程分派的任务，如果可供使用的话。可用性可能是暂时的，因此null结果并不一定意味着此任务正在运行的池的静止。此方法主要用于支持扩展，否则不太有用。
    
    结果
    
    一个任务，或 null如果没有可用
  - pollSubmission
```
protected static ForkJoinTask<?> pollSubmission()
```
    如果当前线程在ForkJoinPool中运行，则不执行外部提交到池的任务（如果有的话）可以取消调度和返回。可用性可能是暂时的，因此null结果并不一定意味着池的静止。这种方法主要是为了支持扩展，而且不太可能有用。
    
    结果
    
    一个任务，或 null如果没有可用
    
    从以下版本开始：
    
    9
  - getForkJoinTaskTag
```
public final short getForkJoinTaskTag()
```
    返回此任务的标签。
    
    结果
    
    该任务的标签
    
    从以下版本开始：
    
    1.8
  - setForkJoinTaskTag
```
public final short setForkJoinTaskTag(short newValue)
```
    原子地设置此任务的标签值并返回旧值。
    
    参数
    
    newValue - 新的标签值
    
    结果
    
    标签的以前的值
    
    从以下版本开始：
    
    1.8
  - compareAndSetForkJoinTaskTag
```
public final boolean compareAndSetForkJoinTaskTag(short expect,
                                                  short update)
```
    以原子方式有条件地设置此任务的标签值。在其他应用程序中，标签可以用作在图上操作的任务中的访问标记，如在处理之前检查： if (task.compareAndSetForkJoinTaskTag((short)0, (short)1))方法，否则退出，因为节点已经被访问。
    
    参数
    
    expect - 预期的标签值
    
    update - 新的标签值
    
    结果
    
    true如果成功; 即当前值等于expect ，更改为update 。
    
    从以下版本开始：
    
    1.8
  - 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 - 可呼叫动作
    
    结果
    
    任务

Class ForkJoinTask<V>

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

构造方法详细信息

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

pollSubmission

getForkJoinTaskTag

setForkJoinTaskTag

compareAndSetForkJoinTaskTag

adapt

adapt

adapt