ForkJoinPool (Java Platform SE 8 )

java.lang.Object
- java.util.concurrent.AbstractExecutorService
- - java.util.concurrent.ForkJoinPool

All Implemented Interfaces:

Executor ， ExecutorService
```
public class ForkJoinPool
extends AbstractExecutorService
```
一个ExecutorService运行ForkJoinTask s。 A ForkJoinPool提供非ForkJoinTask客户ForkJoinPool的入场点，以及管理和监控操作。
一个ForkJoinPool与其他种类的不同ExecutorService主要凭借用人偷盗的：所有的线程池中试图找到并执行其他活动任务提交到池和/或创建（最终阻塞等待工作，如果不存在）的任务。当大多数任务产生其他子任务（大多数ForkJoinTask ）以及许多小任务从外部客户端提交到池时，这可以实现高效的处理。尤其是在构造函数设置asyncMode为真时， ForkJoinPool S还可能适合于与事件式的任务中使用那些从未加入。

静态commonPool()可用，适用于大多数应用。公共池被任何未显式提交到指定池的ForkJoinTask使用。使用公共池通常会减少资源使用（其线程在不使用期间缓慢回收，并在后续使用时恢复）。

对于需要单独的或定制的池中的应用程序，一个ForkJoinPool可与给定的目标并行级来构造; 默认情况下，等于可用处理器的数量。池尝试通过动态添加，挂起或恢复内部工作线程来维护足够的活动（或可用）线程，即使某些任务停止等待加入其他线程。但是，面对阻塞的I / O或其他非托管同步，不能保证这样的调整。嵌套的ForkJoinPool.ManagedBlocker接口可以扩展所容纳的同步类型。

除了执行和生命周期控制方法之外，该类还提供了用于帮助开发，调优和监视fork / join应用程序的状态检查方法（例如getStealCount() ）。此外，方法toString()以方便的形式返回池状态的指示以进行非正式监视。

与其他ExecutorServices的情况一样，下表总结了三个主要任务执行方法。这些设计主要由尚未在当前池中进行fork / join计算的客户端使用。这些方法的主要形式接受的实例ForkJoinTask ，但重载形式也允许的纯混合执行Runnable -或Callable -基础的活动为好。但是，通常情况下，在池中已经执行的任务会使用表中列出的计算内表单，除非使用不通常连接的异步事件式任务，否则在方法选择方面几乎没有区别。
Summary of task execution methods Call from non-fork/join clients Call from within fork/join computations Arrange async execution execute(ForkJoinTask) ForkJoinTask.fork() Await and obtain result invoke(ForkJoinTask) ForkJoinTask.invoke() Arrange exec and obtain Future submit(ForkJoinTask) ForkJoinTask.fork() (ForkJoinTasks are Futures)

公共池默认使用默认参数构建，但这些可以通过设置三个system properties来控制：
- java.util.concurrent.ForkJoinPool.common.parallelism - 并行级别，非负整数
- java.util.concurrent.ForkJoinPool.common.threadFactory - 类名ForkJoinPool.ForkJoinWorkerThreadFactory
- java.util.concurrent.ForkJoinPool.common.exceptionHandler - 一个Thread.UncaughtExceptionHandler的类名
如果一个SecurityManager存在且没有指定工厂，则默认池使用一个工厂提供的线程不启用Permissions 。系统类加载器用于加载这些类。建立这些设置有任何错误，使用默认参数。通过将parallelism属性设置为零，和/或使用可能返回null的工厂，可以禁用或限制公共池中的线程的使用。但是这样做可能导致未连接的任务永远不会被执行。
实现注意事项 ：此实现将运行的最大线程数限制为32767.尝试创建大于最大数目的池导致IllegalArgumentException 。

此实现仅在池关闭或内部资源耗尽时拒绝提交的任务（即抛出RejectedExecutionException ）。
从以下版本开始：

1.7

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`ForkJoinPool.ForkJoinWorkerThreadFactory` 工厂创建新的`ForkJoinWorkerThread` s。
`static interface`	`ForkJoinPool.ManagedBlocker` 用于扩展管理并行性的接口，用于在`ForkJoinPool`中运行的任务。

Field Summary

Fields
Modifier and Type	Field and Description
`static ForkJoinPool.ForkJoinWorkerThreadFactory`	`defaultForkJoinWorkerThreadFactory` 创建一个新的ForkJoinWorkerThread。

构造方法摘要

构造方法
Constructor and Description
`ForkJoinPool()` 创建 `ForkJoinPool`度等于 `Runtime.availableProcessors()` ，使用 default thread factory ，没有UncaughtExceptionHandler和非同步LIFO处理模式。
`ForkJoinPool(int parallelism)` 创建一个 `ForkJoinPool`具有指示的并行级别， default thread factory ，没有UncaughtExceptionHandler和非同步LIFO处理模式。
`ForkJoinPool(int parallelism, ForkJoinPool.ForkJoinWorkerThreadFactory factory, Thread.UncaughtExceptionHandler handler, boolean asyncMode)` 创建一个 `ForkJoinPool`具有给定参数。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`boolean`	`awaitQuiescence(long timeout, TimeUnit unit)` 如果被一个ForkJoinTask调用在这个池中运行，相当于 `ForkJoinTask.helpQuiesce()` 。
`boolean`	`awaitTermination(long timeout, TimeUnit unit)` 阻止所有任务在关闭请求完成后执行，或发生超时，或当前线程中断，以先到者为准。
`static ForkJoinPool`	`commonPool()` 返回公共池实例。
`protected int`	`drainTasksTo(Collection<? super ForkJoinTask<?>> c)` 从调度队列中删除所有可用的未执行的提交和分派任务，并将其添加到给定集合中，而不会更改其执行状态。
`void`	`execute(ForkJoinTask<?> task)` 为异步执行给定任务的排列。
`void`	`execute(Runnable task)` 在将来的某个时间执行给定的命令。
`int`	`getActiveThreadCount()` 返回当前正在窃取或执行任务的线程数的估计。
`boolean`	`getAsyncMode()` 返回 `true`如果此池使用本地先入先出调度模式，用于从未加入的分叉任务。
`static int`	`getCommonPoolParallelism()` 返回公共池的目标并行度级别。
`ForkJoinPool.ForkJoinWorkerThreadFactory`	`getFactory()` 返回用于构建新工人的工厂。
`int`	`getParallelism()` 返回此池的目标并行度级别。
`int`	`getPoolSize()` 返回已启动但尚未终止的工作线程数。
`int`	`getQueuedSubmissionCount()` 返回提交给此池尚未开始执行的任务数量的估计。
`long`	`getQueuedTaskCount()` 返回由工作线程（但不包括提交到池中尚未开始执行的任务）当前在队列中保留的任务总数的估计值。
`int`	`getRunningThreadCount()` 返回等待加入任务或其他受管同步的未阻止的工作线程数的估计。
`long`	`getStealCount()` 返回从另一个线程的工作队列中偷取的任务总数的估计值。
`Thread.UncaughtExceptionHandler`	`getUncaughtExceptionHandler()` 返回由于在执行任务时遇到不可恢复的错误而终止的内部工作线程的处理程序。
`boolean`	`hasQueuedSubmissions()` 返回 `true`如果有提交给该池尚未开始执行任何任务。
`<T> T`	`invoke(ForkJoinTask<T> task)` 执行给定的任务，在完成后返回其结果。
`<T> List<Future<T>>`	`invokeAll(Collection<? extends Callable<T>> tasks)` 执行给定的任务，返回持有他们的状态和结果的所有完成的期货列表。
`boolean`	`isQuiescent()` 如果所有工作线程当前处于空闲状态，则返回 `true` 。
`boolean`	`isShutdown()` 如果此池已关闭，则返回 `true` 。
`boolean`	`isTerminated()` 如果所有任务在关闭后完成，则返回 `true` 。
`boolean`	`isTerminating()` 如果 `true`程序已经开始但尚未完成，则返回true。
`static void`	`managedBlock(ForkJoinPool.ManagedBlocker blocker)` 阻挡符合给定的阻滞剂。
`protected <T> RunnableFuture<T>`	`newTaskFor(Callable<T> callable)` 返回给定可调用任务的 `RunnableFuture` 。
`protected <T> RunnableFuture<T>`	`newTaskFor(Runnable runnable, T value)` 返回给定的可运行和默认值的 `RunnableFuture` 。
`protected ForkJoinTask<?>`	`pollSubmission()` 删除并返回下一个未执行的提交（如果有）。
`void`	`shutdown()` 可能启动有序关闭，其中先前提交的任务被执行，但不会接受任何新的任务。
`List<Runnable>`	`shutdownNow()` 可能尝试取消和/或停止所有任务，并拒绝所有后续提交的任务。
`<T> ForkJoinTask<T>`	`submit(Callable<T> task)` 提交值返回任务以执行，并返回代表任务待处理结果的Future。
`<T> ForkJoinTask<T>`	`submit(ForkJoinTask<T> task)` 提交一个ForkJoinTask来执行。
`ForkJoinTask<?>`	`submit(Runnable task)` 提交一个可运行的任务执行，并返回一个表示该任务的未来。
`<T> ForkJoinTask<T>`	`submit(Runnable task, T result)` 提交一个可运行的任务执行，并返回一个表示该任务的未来。
`String`	`toString()` 返回一个标识此池的字符串，以及它的状态，包括运行状态，并行级和工作和任务计数的指示。

Methods inherited from class java.util.concurrent.AbstractExecutorService
invokeAll, invokeAny, invokeAny

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

- 字段详细信息
  - defaultForkJoinWorkerThreadFactory
```
public static final ForkJoinPool.ForkJoinWorkerThreadFactory defaultForkJoinWorkerThreadFactory
```
    创建一个新的ForkJoinWorkerThread。该工厂被使用，除非在ForkJoinPool构造函数中被覆盖。
- 构造方法详细信息
  - ForkJoinPool
```
public ForkJoinPool()
```
    创建一个 ForkJoinPool度等于 Runtime.availableProcessors() ，使用 default thread factory ，没有UncaughtExceptionHandler和非同步LIFO处理模式。
    
    异常
    
    SecurityException - 如果安全管理器存在，并且主叫方不允许修改线程，因为它不保留RuntimePermission ("modifyThread")
  - ForkJoinPool
```
public ForkJoinPool(int parallelism)
```
    创建具有 ForkJoinPool并行级别的 ForkJoinPool，default thread factory ，没有UncaughtExceptionHandler和非同步LIFO处理模式。
    
    参数
    
    parallelism - 并行级别
    
    异常
    
    IllegalArgumentException - 如果并行度小于或等于零，或大于实现限制
    
    SecurityException - 如果安全管理器存在，并且调用者不允许修改线程，因为它不保留RuntimePermission ("modifyThread")
  - ForkJoinPool
```
public ForkJoinPool(int parallelism,
                    ForkJoinPool.ForkJoinWorkerThreadFactory factory,
                    Thread.UncaughtExceptionHandler handler,
                    boolean asyncMode)
```
    创建一个 ForkJoinPool具有给定参数。
    
    参数
    
    parallelism - 并行级别。对于默认值，请使用Runtime.availableProcessors() 。
    
    factory - 创建新线程的工厂。默认值为defaultForkJoinWorkerThreadFactory 。
    
    handler - 由于执行任务时遇到不可恢复的错误而终止的内部工作线程的处理程序。默认值为null 。
    
    asyncMode - 如果为true，请为从未连接的分叉任务建立本地先进先出调度模式。在工作线程仅处理事件式异步任务的应用程序中，此模式可能比默认的基于本地堆栈的模式更合适。默认值为false 。
    
    异常
    
    IllegalArgumentException - 如果并行度小于或等于零，或大于实现限制
    
    NullPointerException - 如果工厂为空
    
    SecurityException - 如果安全管理器存在，并且主叫方不允许修改线程，因为它不保留RuntimePermission ("modifyThread")
- 方法详细信息
  - commonPool
```
public static ForkJoinPool commonPool()
```
    返回公共池实例。这个游泳池是静态的; 其运行状态不受尝试shutdown()或shutdownNow()的影响。但是，该池和任何正在进行的处理将在程序System.exit(int)自动终止。在程序终止前依赖于异步任务处理完成的任何程序，应在退出之前调用commonPool(). awaitQuiescence 。
    
    结果
    
    公共池实例
    
    从以下版本开始：
    
    1.8
  - invoke
```
public <T> T invoke(ForkJoinTask<T> task)
```
    执行给定的任务，在完成后返回其结果。如果计算遇到未检查的异常或错误，则将其重新定义为此调用的结果。 Rethrown异常的行为与常规异常的方式相同，但如果可能，则包含当前线程以及实际遇到异常的线程的堆栈跟踪（例如使用ex.printStackTrace() ）; 最低限度只有后者。
    
    参数类型
    
    T - 任务结果的类型
    
    参数
    
    task - 任务
    
    结果
    
    任务的结果
    
    异常
    
    NullPointerException - 如果任务为空
    
    RejectedExecutionException - 如果任务无法安排执行
  - execute
```
public void execute(ForkJoinTask<?> task)
```
    为异步执行给定任务的排列。
    
    参数
    
    task - 任务
    
    异常
    
    NullPointerException - 如果任务为空
    
    RejectedExecutionException - 如果任务无法安排执行
  - execute
```
public void execute(Runnable task)
```
    说明从界面： Executor复制
    
    在将来的某个时间执行给定的命令。该命令可以在一个新线程，一个合并的线程中或在调用线程中执行，由Executor实现。
    
    参数
    
    task - 可运行的任务
    
    异常
    
    NullPointerException - 如果任务为空
    
    RejectedExecutionException - 如果任务无法安排执行
  - submit
```
public <T> ForkJoinTask<T> submit(ForkJoinTask<T> task)
```
    提交一个ForkJoinTask来执行。
    
    参数类型
    
    T - 任务结果的类型
    
    参数
    
    task - 提交的任务
    
    结果
    
    任务
    
    异常
    
    NullPointerException - 如果任务为空
    
    RejectedExecutionException - 如果任务无法安排执行
  - submit
```
public <T> ForkJoinTask<T> submit(Callable<T> task)
```
    说明从界面： ExecutorService复制
    
    提交值返回任务以执行，并返回代表任务待处理结果的Future。未来的get方法将在成功完成后返回任务的结果。
    如果您想立即阻止等待任务，您可以使用result = exec.submit(aCallable).get();格式的result = exec.submit(aCallable).get();
    
    注意： Executors类包括一组可以将一些其他常见的类似闭包的对象（例如PrivilegedAction）转换为Callable表单的方法，以便他们可以提交。
    
    Specified by:
    
    submit在界面 ExecutorService
    
    重写：
    
    submit在类别 AbstractExecutorService
    
    参数类型
    
    T - 任务结果的类型
    
    参数
    
    task - 提交的任务
    
    结果
    
    一个未来的代表，待完成任务
    
    异常
    
    NullPointerException - 如果任务为空
    
    RejectedExecutionException - 如果任务无法安排执行
  - submit
```
public <T> ForkJoinTask<T> submit(Runnable task,
                                  T result)
```
    说明从界面复制： ExecutorService
    
    提交一个可运行的任务执行，并返回一个表示该任务的未来。未来的get方法将在成功完成后返回给定的结果。
    
    Specified by:
    
    submit在界面 ExecutorService
    
    重写：
    
    submit在类别 AbstractExecutorService
    
    参数类型
    
    T - 结果的类型
    
    参数
    
    task - 提交的任务
    
    result - 结果返回
    
    结果
    
    一个未来的代表，待完成任务
    
    异常
    
    NullPointerException - 如果任务为空
    
    RejectedExecutionException - 如果任务无法安排执行
  - submit
```
public ForkJoinTask<?> submit(Runnable task)
```
    说明从界面： ExecutorService复制
    
    提交一个可运行的任务执行，并返回一个表示该任务的未来。未来的get方法将返回null 成功完成时。
    
    Specified by:
    
    submit在界面 ExecutorService
    
    重写：
    
    submit在类别 AbstractExecutorService
    
    参数
    
    task - 提交的任务
    
    结果
    
    一个未来的代表，待完成任务
    
    异常
    
    NullPointerException - 如果任务为空
    
    RejectedExecutionException - 如果任务无法安排执行
  - invokeAll
```
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
```
    说明从界面： ExecutorService复制
    
    执行给定的任务，返回持有他们的状态和结果的所有完成的期货列表。 Future.isDone()是返回列表的每个元素的true 。请注意， 完成的任务可能会正常终止或抛出异常。如果在此操作正在进行中修改了给定的集合，则此方法的结果是未定义的。
    
    Specified by:
    
    invokeAll在界面 ExecutorService
    
    重写：
    
    invokeAll ，在类别 AbstractExecutorService
    
    参数类型
    
    T - 从任务返回的值的类型
    
    参数
    
    tasks - 任务的收集
    
    结果
    
    表示任务的期货列表，按照给定任务列表的迭代器产生的顺序顺序，每个都已完成
    
    异常
    
    NullPointerException - 如果任务或其任何元素是 null
    
    RejectedExecutionException - 如果任何任务无法安排执行
  - getFactory
```
public ForkJoinPool.ForkJoinWorkerThreadFactory getFactory()
```
    返回用于构建新工人的工厂。
    
    结果
    
    工厂用于建造新工人
  - getUncaughtExceptionHandler
```
public Thread.UncaughtExceptionHandler getUncaughtExceptionHandler()
```
    返回由于在执行任务时遇到不可恢复的错误而终止的内部工作线程的处理程序。
    
    结果
    
    处理程序，或 null如果没有
  - getParallelism
```
public int getParallelism()
```
    返回此池的目标并行度级别。
    
    结果
    
    这个池的目标平行度水平
  - getCommonPoolParallelism
```
public static int getCommonPoolParallelism()
```
    返回公共池的目标并行度级别。
    
    结果
    
    共同池的目标平行度水平
    
    从以下版本开始：
    
    1.8
  - getPoolSize
```
public int getPoolSize()
```
    返回已启动但尚未终止的工作线程数。这种方法返回的结果可能与getParallelism()有所不同，当线程被创建以在其他协作阻塞时保持并行性。
    
    结果
    
    工作线程数
  - getAsyncMode
```
public boolean getAsyncMode()
```
    返回 true如果此池对于从未加入的分叉任务使用本地先进先出调度模式。
    
    结果
    
    true如果此池使用异步模式
  - getRunningThreadCount
```
public int getRunningThreadCount()
```
    返回等待加入任务或其他受管同步的未阻止的工作线程数的估计。此方法可能会高估正在运行的线程数。
    
    结果
    
    工作线程数
  - getActiveThreadCount
```
public int getActiveThreadCount()
```
    返回当前正在窃取或执行任务的线程数的估计。此方法可能会高估活动线程的数量。
    
    结果
    
    活动线程的数量
  - isQuiescent
```
public boolean isQuiescent()
```
    如果所有工作线程当前处于空闲状态，则返回true 。空闲的工作者是无法获取执行任务的工作，因为没有可用于从其他线程窃取，并且没有等待提交给池。这种方法是保守的它可能不会在所有线程空闲时立即返回true ，但如果线程保持不活动，则最终会变为true。
    
    结果
    
    true如果所有线程当前都处于空闲状态
  - getStealCount
```
public long getStealCount()
```
    返回从另一个线程的工作队列中偷取的任务总数的估计值。报告的价值低估了池不是静止时的实际偷窃总数。该值可能对于监视和调优fork / join程序很有用：通常来说，窃取计数应该足够高以保持线程忙，但足够低以避免线程间的开销和争用。
    
    结果
    
    偷窃的次数
  - getQueuedTaskCount
```
public long getQueuedTaskCount()
```
    返回由工作线程（但不包括提交到池中尚未开始执行的任务）当前在队列中保留的任务总数的估计值。该值只是通过遍历池中的所有线程获得的近似值。此方法对于调整任务粒度可能很有用。
    
    结果
    
    排队任务的数量
  - getQueuedSubmissionCount
```
public int getQueuedSubmissionCount()
```
    返回提交给此池尚未开始执行的任务数量的估计。该方法可能需要与提交的数量成比例的时间。
    
    结果
    
    排队提交的数量
  - hasQueuedSubmissions
```
public boolean hasQueuedSubmissions()
```
    返回 true如果有提交给该池尚未开始执行任何任务。
    
    结果
    
    true如果有任何排队提交
  - pollSubmission
```
protected ForkJoinTask<?> pollSubmission()
```
    删除并返回下一个未执行的提交（如果有）。此方法在对具有多个池的系统中重新分配工作的此类的扩展中可能很有用。
    
    结果
    
    下一次提交，或 null如果没有
  - drainTasksTo
```
protected int drainTasksTo(Collection<? super ForkJoinTask<?>> c)
```
    从调度队列中删除所有可用的未执行的提交和分派任务，并将其添加到给定集合中，而不会更改其执行状态。这些可能包括人为生成或包装的任务。该方法仅在池已知静止时被调用。其他时间的调用可能不会删除所有任务。尝试向集合c添加元素时遇到的c可能导致在抛出关联的异常时，元素既不在两个集合中，也可能不是两个集合。如果在操作进行中修改了指定的集合，则此操作的行为是未定义的。
    
    参数
    
    c - 传输元素的集合
    
    结果
    
    转移的元素数量
  - toString
```
public String toString()
```
    返回一个标识此池的字符串，以及它的状态，包括运行状态，并行级和工作和任务计数的指示。
    
    重写：
    
    toString在类别 Object
    
    结果
    
    一个标识这个池的字符串，以及它的状态
  - shutdown
```
public void shutdown()
```
    可能启动有序关闭，其中先前提交的任务被执行，但不会接受任何新的任务。如果这是commonPool() ，调用对执行状态没有影响，如果已经关闭，则不起作用。在此方法过程中同时提交的任务可能会被拒绝，也可能不会被拒绝。
    
    异常
    
    SecurityException - 如果安全管理器存在，并且主叫方不允许修改线程，因为它不保留RuntimePermission ("modifyThread")
  - shutdownNow
```
public List<Runnable> shutdownNow()
```
    可能尝试取消和/或停止所有任务，并拒绝所有后续提交的任务。如果这是commonPool() ，调用对执行状态没有影响，如果已经关闭，则不起作用。否则，在此方法过程中同时提交或执行的任务可能会被拒绝也可能不会被拒绝。该方法取消现有和未执行的任务，以便在存在任务依赖性的情况下允许终止。所以方法总是返回一个空列表（与其他执行程序不同）。
    
    结果
    
    一个空的列表
    
    异常
    
    SecurityException - 如果存在安全管理员，并且主叫方不允许修改线程，因为它不保留RuntimePermission ("modifyThread")
  - isTerminated
```
public boolean isTerminated()
```
    如果所有任务在关闭后完成，则返回 true 。
    
    结果
    
    true如果所有任务已完成以后关闭
  - isTerminating
```
public boolean isTerminating()
```
    如果true程序已经开始但尚未完成，则返回true。此方法可能对调试有用。返回true报告了关机后的足够的时间可能表示提交的任务已经忽略或抑制中断，或正在等待I / O，导致执行器不能正常终止。（请参阅ForkJoinTask的咨询说明，说明任务通常不应该阻塞操作，但如果这样做，则必须中断它们）。
    
    结果
    
    true如果终止但尚未终止
  - isShutdown
```
public boolean isShutdown()
```
    如果此池已关闭，则返回 true 。
    
    结果
    
    true如果这个池已被关闭
  - awaitTermination
```
public boolean awaitTermination(long timeout,
                                TimeUnit unit)
                         throws InterruptedException
```
    阻止所有任务在关闭请求完成后执行，或发生超时，或当前线程中断，以先到者为准。由于commonPool()永远不会终止，直到程序关闭，当应用到公共池，这种方法相当于awaitQuiescence(long, TimeUnit) ，但总是返回false 。
    
    参数
    
    timeout - 等待的最长时间
    
    unit - 超时参数的时间单位
    
    结果
    
    true如果这个执行者终止了，并且 false之前的超时时间是false
    
    异常
    
    InterruptedException - 如果在等待时中断
  - awaitQuiescence
```
public boolean awaitQuiescence(long timeout,
                               TimeUnit unit)
```
    如果被一个ForkJoinTask调用在这个池中运行，相当于ForkJoinTask.helpQuiesce() 。否则，等待和/或尝试协助执行任务，直到此池isQuiescent()或指示的超时过去。
    
    参数
    
    timeout - 等待的最长时间
    
    unit - 超时参数的时间单位
    
    结果
    
    true如果静止; false如果超时已过。
  - managedBlock
```
public static void managedBlock(ForkJoinPool.ManagedBlocker blocker)
                         throws InterruptedException
```
    阻挡符合给定的阻滞剂。如果当前线程是ForkJoinWorkerThread ，如果需要，该方法可能会排列一个备用线程，以确保当前线程被阻塞时的足够的并行性。
    如果呼叫者不是ForkJoinTask ，则此方法在行为上相当于
```
   while (!blocker.isReleasable()) if (blocker.block()) return;  
```
    如果来电者是ForkJoinTask ，那么这个池可以先扩展，以确保并行性，然后调整。
    参数
    
    blocker - 阻滞剂
    
    异常
    
    InterruptedException - 如果blocker.block这样做
  - newTaskFor
```
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable,
                                           T value)
```
    描述从类别： AbstractExecutorService复制
    
    为给定的可运行和默认值返回 RunnableFuture 。
    
    重写：
    
    newTaskFor在类别 AbstractExecutorService
    
    参数类型
    
    T - 给定值的类型
    
    参数
    
    runnable - 正在包装的可运行任务
    
    value - 返回的未来的默认值
    
    结果
    
    一个 RunnableFuture ，当运行时，将运行底层的可运行程序，作为 Future ，它将产生给定的值作为其结果，并提供取消基础任务
  - newTaskFor
```
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable)
```
    描述从类别： AbstractExecutorService复制
    
    为给定的可调用任务返回 RunnableFuture 。
    
    重写：
    
    newTaskFor在类别 AbstractExecutorService
    
    参数类型
    
    T - 可调用结果的类型
    
    参数
    
    callable - 被打包的 callable任务
    
    结果
    
    一个 RunnableFuture ，当运行时，将调用底层可调用，并且作为 Future将作为其结果产生可调用的结果，并提供取消基础任务

Class ForkJoinPool

Nested Class Summary

Field Summary

构造方法摘要

方法摘要

Methods inherited from class java.util.concurrent.AbstractExecutorService

Methods inherited from class java.lang.Object

字段详细信息

defaultForkJoinWorkerThreadFactory

构造方法详细信息

ForkJoinPool

ForkJoinPool

ForkJoinPool

方法详细信息

commonPool

invoke

execute

execute

submit

submit

submit

submit

invokeAll

getFactory

getUncaughtExceptionHandler

getParallelism

getCommonPoolParallelism

getPoolSize

getAsyncMode

getRunningThreadCount

getActiveThreadCount

isQuiescent

getStealCount

getQueuedTaskCount

getQueuedSubmissionCount

hasQueuedSubmissions

pollSubmission

drainTasksTo

toString

shutdown

shutdownNow

isTerminated

isTerminating

isShutdown

awaitTermination

awaitQuiescence

managedBlock

newTaskFor

newTaskFor