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 ForkJoinTasks。一 ForkJoinPool提供意见的非 ForkJoinTask客户的切入点，以及管理和监控操作。

一个ForkJoinPool不同于主要采用工作偷ExecutorService其他美德：所有的线程池中试图找到并执行向池和/或其他活动任务创建任务（最终阻断如果没有等待工作）。这使得高效的处理时，大多数的任务产生其他任务（大部分ForkJoinTasks），以及在许多小的任务是从外部客户提交的池。特别是设置asyncmode真正在构造函数时，ForkJoinPools也可适当用于事件式的任务，没有加入。

静态commonPool()可用，适合大多数应用程序。常见的游泳池是由任何forkjointask不明确提交指定的池。使用普通池通常会降低资源的使用（它的线程正在慢慢的再生过程中非使用期和恢复后使用）。

对于需要单独的或自定义库的应用，一个ForkJoinPool可能与给定的目标并行层次构建；默认情况下，等于可用处理器的数量。该池试图通过动态添加、挂起或恢复内部工作线程来保持足够的活动（或可用）线程，即使一些任务被停止等待加入其他线程。然而，没有这样的调整是保证在面对阻塞I/O或其他非托管同步。嵌套ForkJoinPool.ManagedBlocker接口可以扩展的同步类容。

除了执行和生命周期控制方法，这类提供状态检查方法（例如getStealCount()），旨在帮助开发，调试，监测Fork/join应用。同时，方法toString()返回正规监测的一个方便的形式池状态指示。

如与其他executorservices而言，主要有三个任务的执行方法如下表。这些被设计用于主要由客户没有已经从事在当前池中的叉/连接的计算。这些方法的主要形式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启用。系统类装载器被用来加载这些类。在建立这些设置的任何错误时，使用默认参数。它可以禁用或限制通过设置并行性为零的普通线程池的使用，和/或使用一个工厂，可能会返回 null。然而这样做可能导致不不执行任务。

实现注意事项：实施限制运行的线程的最大数量为32767。试图创建最大数量大于IllegalArgumentException结果池。

这个实现拒绝提交的任务（即，通过投掷RejectedExecutionException）只有当游泳池关闭或内部资源已经枯竭。

从以下版本开始：: 一点七

Nested Class Summary

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

Field Summary

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

构造方法摘要

构造方法
Constructor and Description
`ForkJoinPool()` 创建一个平行相等 `Runtime.availableProcessors()` `ForkJoinPool`，使用 default thread factory，没有uncaughtexceptionhandler，后进先出法和非异步处理模式。
`ForkJoinPool(int parallelism)` 创建一个指定的并行度， `ForkJoinPool`的 default thread factory，没有uncaughtexceptionhandler，后进先出法和非异步处理模式。
`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`如果终止的过程已经开始但尚未完成的。
`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)` 提交一个值返回任务执行，并返回一个表示任务挂起结果的未来。
`<T> ForkJoinTask<T>`	`submit(ForkJoinTask<T> task)` 提交forkjointask执行。
`ForkJoinTask<?>`	`submit(Runnable task)` 提交执行一个Runnable任务并返回一个表示该任务的未来。
`<T> ForkJoinTask<T>`	`submit(Runnable task, T result)` 提交执行一个Runnable任务并返回一个表示该任务的未来。
`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

- Field Detail
  - defaultForkJoinWorkerThreadFactory
```
public static final ForkJoinPool.ForkJoinWorkerThreadFactory defaultForkJoinWorkerThreadFactory
```
    创建一个新的forkjoinworkerthread。本厂除forkjoinpool重写使用构造函数。
- Constructor Detail
  - ForkJoinPool
```
public ForkJoinPool()
```
    创建一个平行相等 Runtime.availableProcessors() ForkJoinPool，使用 default thread factory，没有uncaughtexceptionhandler，后进先出法和非异步处理模式。
    
    异常
    
    SecurityException -如果存在一个安全管理和允许修改线程，因为它不支持 RuntimePermission ("modifyThread")不来电
  - ForkJoinPool
```
public ForkJoinPool(int parallelism)
```
    创建一个指定的并行度， ForkJoinPool的 default thread factory，没有uncaughtexceptionhandler，后进先出法和非异步处理模式。
    
    参数
    
    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 -如果属实，建立地方先出叉的任务，没有加入调度模式。这种模式可能比默认的本地堆栈为基础的模式更合适，在应用程序中，工作线程只处理事件样式异步任务。为默认值，使用 false。
    
    异常
    
    IllegalArgumentException如果平行度小于或等于零，或者大于实施限制
    
    NullPointerException -如果工厂是空的
    
    SecurityException -如果存在一个安全管理和允许修改线程，因为它不支持 RuntimePermission ("modifyThread")不来电
- 方法详细信息
  - commonPool
```
public static ForkJoinPool commonPool()
```
    返回公用池实例。这个游泳池是静态构造；其运行状态是由试图 shutdown()或 shutdownNow()受影响。然而这池和正在进行的任何加工自动终止程序 System.exit(int)。任何程序，依靠异步任务处理完成之前终止程序应该调用 commonPool(). awaitQuiescence，退出前。
    
    结果
    
    公用池实例
    
    从以下版本开始：
    
    一点八
  - invoke
```
public <T> T invoke(ForkJoinTask<T> task)
```
    完成给定的任务，完成后返回其结果。如果计算遇到一个unchecked异常或错误，它会被重新抛出作为该调用的结果。重抛出异常的行为相同的方式作为规则的例外，但是，在可能的情况下，包含堆栈跟踪（如显示例如使用 ex.printStackTrace()）的当前线程以及线程实际上遇到例外；最小的只有后者。
    
    参数类型
    
    T -任务类型结果
    
    参数
    
    task -任务
    
    结果
    
    任务结果
    
    异常
    
    NullPointerException -如果任务是空的
    
    RejectedExecutionException如果任务不能按计划执行
  - execute
```
public void execute(ForkJoinTask<?> task)
```
    安排（异步）给定的任务的执行。
    
    参数
    
    task -任务
    
    异常
    
    NullPointerException -如果任务是空的
    
    RejectedExecutionException如果任务不能按计划执行
  - execute
```
public void execute(Runnable task)
```
    从接口复制的描述： Executor
    
    在未来的某个时间执行给定的命令。命令可以在一个新的线程上执行，在池的线程，或者调用线程，在 Executor实施自由裁量权。
    
    参数
    
    task的Runnable任务
    
    异常
    
    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
    
    提交一个值返回任务执行，并返回一个表示任务挂起结果的未来。未来的 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
    
    提交执行一个Runnable任务并返回一个表示该任务的未来。未来的 get方法将给定的结果成功完成后返回。
    
    Specified by:
    
    submit 接口 ExecutorService
    
    重写：
    
    submit 方法重写，继承类 AbstractExecutorService
    
    参数类型
    
    T -结果的类型
    
    参数
    
    task -任务提交
    
    result -结果返回
    
    结果
    
    一个即将完成的任务的未来
    
    异常
    
    NullPointerException -如果任务是空的
    
    RejectedExecutionException如果任务不能按计划执行
  - submit
```
public ForkJoinTask<?> submit(Runnable task)
```
    从接口复制的描述： ExecutorService
    
    提交执行一个Runnable任务并返回一个表示该任务的未来。未来的 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()
```
    返回公共池的目标并行级别。
    
    结果
    
    公共游泳池的目标并行度
    
    从以下版本开始：
    
    一点八
  - 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目前闲置
  - getStealCount
```
public long getStealCount()
```
    返回从一个线程的工作队列中被另一个线程窃取的总任务数的估计。报告的价值低估实际总数抢断当池不是静止的。此值可能是有用的监视和调整叉/连接程序：在一般情况下，偷计数应该足够高，以保持线程繁忙，但足够低，以避免开销和跨线程争用。
    
    结果
    
    偷的数量
  - 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 -收集传递元素
    
    结果
    
    传输的元素数
  - 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报道了足够长的时间后关机可能表明提交的任务都忽略或抑制干扰，或等待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 - timeout参数的时间单位
    
    结果
    
    true如果执行终止和 false如果超时后终止
    
    异常
    
    InterruptedException如果中断等待
  - awaitQuiescence
```
public boolean awaitQuiescence(long timeout,
                               TimeUnit unit)
```
    如果被forkjointask池中运行，相当的效果 ForkJoinTask.helpQuiesce()。否则，等待和/或试图帮助完成任务，直到这个池 isQuiescent()或指定超时的流逝。
    
    参数
    
    timeout -最大等待时间
    
    unit - timeout参数的时间单位
    
    结果
    
    true如果静止； false如果超时时间。
  - managedBlock
```
public static void managedBlock(ForkJoinPool.ManagedBlocker blocker)
                         throws InterruptedException
```
    块符合给定的阻滞剂。如果当前线程是一个 ForkJoinWorkerThread，这种方法可能安排一个空闲线程如果要保证足够的并行而阻塞当前线程激活。
    如果对方不是ForkJoinTask，这种方法是行为等同于
```
 while (!blocker.isReleasable())
   if (blocker.block())
     return;
 
```
    如果对方是一个 ForkJoinTask池，然后5月1日扩大到保证并行，后来调整。
    参数
    
    blocker -受体阻滞剂
    
    异常
    
    InterruptedException -如果blocker.block这样做
  - newTaskFor
```
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable,
                                           T value)
```
    从阶级复制的描述： AbstractExecutorService
    
    返回一个 RunnableFuture为给定的运行与默认值。
    
    重写：
    
    newTaskFor 方法重写，继承类 AbstractExecutorService
    
    参数类型
    
    T -给定的值的类型
    
    参数
    
    runnable的Runnable任务包
    
    value -返回未来的默认值
    
    结果
    
    一个 RunnableFuture，运行时，将运行的基本运行和它作为一个 Future，将给定的值作为结果为基本任务取消
  - newTaskFor
```
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable)
```
    从阶级复制的描述： AbstractExecutorService
    
    返回给调用任务 RunnableFuture。
    
    重写：
    
    newTaskFor 方法重写，继承类 AbstractExecutorService
    
    参数类型
    
    T -可调用的结果的类型
    
    参数
    
    callable -可赎回的任务包
    
    结果
    
    一个 RunnableFuture，运行时，会调用底层可赎回的，作为一个 Future，产量将可调用的结果作为其结果为基本任务取消

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 ForkJoinPool

Nested Class Summary

Field Summary

构造方法摘要

方法摘要

Methods inherited from class java.util.concurrent.AbstractExecutorService

Methods inherited from class java.lang.Object

Field Detail

defaultForkJoinWorkerThreadFactory

Constructor Detail

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