Executors (Java Platform SE 8 )

java.lang.Object
- java.util.concurrent.Executors

```
public class Executors
extends Object
```
工厂和工具方法Executor ， ExecutorService ， ScheduledExecutorService ， ThreadFactory和Callable在此包中定义的类。该类支持以下几种方法：
- 创建并返回一个ExecutorService设置的常用的配置设置的方法。
- 创建并返回一个ScheduledExecutorService的方法，其中设置了常用的配置设置。
- 创建并返回“包装”ExecutorService的方法，通过使实现特定的方法无法访问来禁用重新配置。
- 创建并返回将新创建的线程设置为已知状态的ThreadFactory的方法。
- 创建并返回一个方法Callable出的其他闭包形式，这样他们就可以在需要的执行方法使用Callable 。
从以下版本开始：

1.5

方法摘要

所有方法静态方法具体的方法
Modifier and Type	Method and Description
`static Callable<Object>`	`callable(PrivilegedAction<?> action)` 返回一个`Callable`对象，当被调用时，它运行给定的特权动作并返回其结果。
`static Callable<Object>`	`callable(PrivilegedExceptionAction<?> action)` 返回一个`Callable`对象，该对象在被调用时运行给定的特权异常操作并返回其结果。
`static Callable<Object>`	`callable(Runnable task)` 返回一个`Callable`对象，当被调用时，它运行给定的任务并返回`null` 。
`static <T> Callable<T>`	`callable(Runnable task, T result)` 返回一个`Callable`对象，当被调用时，它运行给定的任务并返回给定的结果。
`static ThreadFactory`	`defaultThreadFactory()` 返回用于创建新线程的默认线程工厂。
`static ExecutorService`	`newCachedThreadPool()` 创建一个根据需要创建新线程的线程池，但在可用时将重新使用以前构造的线程。
`static ExecutorService`	`newCachedThreadPool(ThreadFactory threadFactory)` 创建一个根据需要创建新线程的线程池，但在可用时将重新使用以前构造的线程，并在需要时使用提供的ThreadFactory创建新线程。
`static ExecutorService`	`newFixedThreadPool(int nThreads)` 创建一个线程池，该线程池重用固定数量的从共享无界队列中运行的线程。
`static ExecutorService`	`newFixedThreadPool(int nThreads, ThreadFactory threadFactory)` 创建一个线程池，重用固定数量的线程，从共享无界队列中运行，使用提供的ThreadFactory在需要时创建新线程。
`static ScheduledExecutorService`	`newScheduledThreadPool(int corePoolSize)` 创建一个线程池，可以调度命令在给定的延迟之后运行，或定期执行。
`static ScheduledExecutorService`	`newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)` 创建一个线程池，可以调度命令在给定的延迟之后运行，或定期执行。
`static ExecutorService`	`newSingleThreadExecutor()` 创建一个使用从无界队列运行的单个工作线程的执行程序。
`static ExecutorService`	`newSingleThreadExecutor(ThreadFactory threadFactory)` 创建一个使用单个工作线程运行无界队列的执行程序，并在需要时使用提供的ThreadFactory创建一个新线程。
`static ScheduledExecutorService`	`newSingleThreadScheduledExecutor()` 创建一个单线程执行器，可以调度命令在给定的延迟之后运行，或定期执行。
`static ScheduledExecutorService`	`newSingleThreadScheduledExecutor(ThreadFactory threadFactory)` 创建一个单线程执行器，可以调度命令在给定的延迟之后运行，或定期执行。
`static ExecutorService`	`newWorkStealingPool()` 创建使用所有 `available processors`作为其目标并行级别的工作窃取线程池。
`static ExecutorService`	`newWorkStealingPool(int parallelism)` 创建一个维护足够的线程以支持给定的并行级别的线程池，并且可以使用多个队列来减少争用。
`static <T> Callable<T>`	`privilegedCallable(Callable<T> callable)` 返回一个`Callable`对象，当被调用时，将在当前访问控制上下文中执行给定的`callable` 。
`static <T> Callable<T>`	`privilegedCallableUsingCurrentClassLoader(Callable<T> callable)` 返回一个`Callable`对象，当被调用时，将在当前访问控制上下文中执行给定的`callable` ，当前上下文类加载器作为上下文类加载器。
`static ThreadFactory`	`privilegedThreadFactory()` 返回一个用于创建与当前线程具有相同权限的新线程的线程工厂。
`static ExecutorService`	`unconfigurableExecutorService(ExecutorService executor)` 返回一个将所有定义的`ExecutorService`方法委托给给定执行程序的对象，但不能以其他方式使用转换方式访问。
`static ScheduledExecutorService`	`unconfigurableScheduledExecutorService(ScheduledExecutorService executor)` 返回一个将所有定义的`ScheduledExecutorService`方法委托给给定执行程序的对象，但不能以其他方式使用转换方式访问。

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

- 方法详细信息
  - newFixedThreadPool
```
public static ExecutorService newFixedThreadPool(int nThreads)
```
    创建一个线程池，该线程池重用固定数量的从共享无界队列中运行的线程。在任何时候，最多nThreads线程将处于主动处理任务。如果所有线程处于活动状态时都会提交其他任务，则它们将等待队列中直到线程可用。如果任何线程由于在关闭之前的执行期间发生故障而终止，则如果需要执行后续任务，则新线程将占用它。池中的线程将存在，直到它明确地为shutdown 。
    
    参数
    
    nThreads - 池中的线程数
    
    结果
    
    新创建的线程池
    
    异常
    
    IllegalArgumentException - 如果是 nThreads <= 0
  - newWorkStealingPool
```
public static ExecutorService newWorkStealingPool(int parallelism)
```
    创建一个维护足够的线程以支持给定的并行级别的线程池，并且可以使用多个队列来减少争用。并行级别对应于主动参与或可以从事任务处理的最大线程数。线程的实际数量可以动态增长和收缩。工作窃取池不保证执行提交的任务的顺序。
    
    参数
    
    parallelism - 目标平行度水平
    
    结果
    
    新创建的线程池
    
    异常
    
    IllegalArgumentException - 如果是 parallelism <= 0
    
    从以下版本开始：
    
    1.8
  - newWorkStealingPool
```
public static ExecutorService newWorkStealingPool()
```
    使用所有 available processors作为其目标并行级别创建一个工作窃取线程池。
    
    结果
    
    新创建的线程池
    
    从以下版本开始：
    
    1.8
    
    另请参见：
    
    newWorkStealingPool(int)
  - newFixedThreadPool
```
public static ExecutorService newFixedThreadPool(int nThreads,
                                                 ThreadFactory threadFactory)
```
    创建一个线程池，重用固定数量的线程，从共享无界队列中运行，使用提供的ThreadFactory在需要时创建新线程。在任何时候，最多nThreads个线程将处于主动处理任务。如果所有线程处于活动状态时都会提交其他任务，则它们将等待队列中直到线程可用。如果任何线程由于在关闭之前的执行期间发生故障而终止，则如果需要执行后续任务，则新线程将占用它。池中的线程将存在，直到它明确地为shutdown 。
    
    参数
    
    nThreads - 池中的线程数
    
    threadFactory - 工厂在创建新线程时使用
    
    结果
    
    新创建的线程池
    
    异常
    
    NullPointerException - 如果threadFactory为null
    
    IllegalArgumentException - 如果是 nThreads <= 0
  - newSingleThreadExecutor
```
public static ExecutorService newSingleThreadExecutor()
```
    创建一个使用从无界队列运行的单个工作线程的执行程序。（请注意，如果这个单个线程由于在关闭之前的执行过程中发生故障而终止，则如果需要执行后续任务，则新的线程将占用它。）任务保证顺序执行，并且不超过一个任务将被激活在任何给定的时间。与其他等效的newFixedThreadPool(1) newFixedThreadPool(1) ，返回的执行器保证不被重新配置以使用额外的线程。
    
    结果
    
    新创建的单线程执行器
  - newSingleThreadExecutor
```
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)
```
    创建一个使用单个工作线程运行无界队列的执行程序，并在需要时使用提供的ThreadFactory创建一个新线程。与其他等效的newFixedThreadPool(1, threadFactory) newFixedThreadPool(1, threadFactory) ，返回的执行器保证不被重新配置以使用额外的线程。
    
    参数
    
    threadFactory - 工厂在创建新线程时使用
    
    结果
    
    新创建的单线程执行器
    
    异常
    
    NullPointerException - 如果threadFactory为null
  - newCachedThreadPool
```
public static ExecutorService newCachedThreadPool()
```
    创建一个根据需要创建新线程的线程池，但在可用时将重新使用以前构造的线程。这些池通常会提高执行许多短暂异步任务的程序的性能。调用execute将重用以前构造的线程（如果可用）。如果没有可用的线程，将创建一个新的线程并将其添加到该池中。未使用六十秒的线程将被终止并从缓存中删除。因此，长时间保持闲置的池将不会消耗任何资源。请注意，可以使用ThreadPoolExecutor构造函数创建具有相似属性但不同详细信息的池（例如，超时参数）。
    
    结果
    
    新创建的线程池
  - newCachedThreadPool
```
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)
```
    创建一个根据需要创建新线程的线程池，但在可用时将重新使用以前构造的线程，并在需要时使用提供的ThreadFactory创建新线程。
    
    参数
    
    threadFactory - 创建新线程时使用的工厂
    
    结果
    
    新创建的线程池
    
    异常
    
    NullPointerException - 如果threadFactory为null
  - newSingleThreadScheduledExecutor
```
public static ScheduledExecutorService newSingleThreadScheduledExecutor()
```
    创建一个单线程执行器，可以调度命令在给定的延迟之后运行，或定期执行。（请注意，如果这个单个线程由于在关闭之前的执行过程中发生故障而终止，则如果需要执行后续任务，则新的线程将占用它。）任务保证顺序执行，并且不超过一个任务将被激活在任何给定的时间。与其他等效的newScheduledThreadPool(1) newScheduledThreadPool(1) ，返回的执行器保证不被重新配置以使用额外的线程。
    
    结果
    
    新创建的预定执行者
  - newSingleThreadScheduledExecutor
```
public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory)
```
    创建一个单线程执行器，可以调度命令在给定的延迟之后运行，或定期执行。（请注意，如果这个单个线程由于在关闭之前的执行过程中发生故障而终止，则如果需要执行后续任务，则新的线程将占用它。）任务保证顺序执行，并且不超过一个任务将被激活在任何给定的时间。与其他等效的newScheduledThreadPool(1, threadFactory) newScheduledThreadPool(1, threadFactory) ，返回的执行器保证不被重新配置以使用额外的线程。
    
    参数
    
    threadFactory - 创建新线程时使用的工厂
    
    结果
    
    一个新创建的预定执行者
    
    异常
    
    NullPointerException - 如果threadFactory为null
  - newScheduledThreadPool
```
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
```
    创建一个线程池，可以调度命令在给定的延迟之后运行，或定期执行。
    
    参数
    
    corePoolSize - 要保留在池中的线程数，即使它们处于空闲状态
    
    结果
    
    一个新创建的线程池
    
    异常
    
    IllegalArgumentException - 如果是 corePoolSize < 0
  - newScheduledThreadPool
```
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize,
                                                              ThreadFactory threadFactory)
```
    创建一个线程池，可以调度命令在给定的延迟之后运行，或定期执行。
    
    参数
    
    corePoolSize - 要保留在池中的线程数，即使它们处于空闲状态
    
    threadFactory - 执行程序创建新线程时使用的工厂
    
    结果
    
    一个新创建的线程池
    
    异常
    
    IllegalArgumentException - 如果是 corePoolSize < 0
    
    NullPointerException - 如果threadFactory为null
  - unconfigurableExecutorService
```
public static ExecutorService unconfigurableExecutorService(ExecutorService executor)
```
    返回一个将所有定义的ExecutorService方法委托给给定执行程序的对象，但不会使用任何其他可能使用转换访问的方法。这提供了一种安全地“冻结”配置并且不允许调整给定的具体实现的方法。
    
    参数
    
    executor - 底层实现
    
    结果
    
    一个 ExecutorService例子
    
    异常
    
    NullPointerException - 如果执行器为空
  - unconfigurableScheduledExecutorService
```
public static ScheduledExecutorService unconfigurableScheduledExecutorService(ScheduledExecutorService executor)
```
    返回一个将所有定义的ScheduledExecutorService方法委托给给定执行程序的对象，但不能以其他方式使用转换方式访问。这提供了一种安全地“冻结”配置并且不允许调整给定的具体实现的方法。
    
    参数
    
    executor - 底层实现
    
    结果
    
    一个 ScheduledExecutorService实例
    
    异常
    
    NullPointerException - 如果执行者为空
  - defaultThreadFactory
```
public static ThreadFactory defaultThreadFactory()
```
    返回用于创建新线程的默认线程工厂。该工厂在同一个ThreadGroup中创建了Executor使用的所有新线程。如果有一个SecurityManager ，它使用组System.getSecurityManager() ，否则该组的线程调用这个defaultThreadFactory方法。每个新线程被创建为非守护线程，优先级设置为Thread.NORM_PRIORITY中的较小者，线程组中允许的最大优先级。新线程具有可通过访问名字Thread.getName() 池-N-thread-M的 ，其中N是此工厂的序列号，M是此工厂所创建线程的序列号。
    
    结果
    
    线工厂
  - privilegedThreadFactory
```
public static ThreadFactory privilegedThreadFactory()
```
    返回一个用于创建与当前线程具有相同权限的新线程的线程工厂。该工厂创建与defaultThreadFactory()相同设置的线程，另外将新线程的AccessControlContext和contextClassLoader设置为与调用此privilegedThreadFactory方法的线程相同。可以在AccessController.doPrivileged操作中创建一个新的privilegedThreadFactory ，设置当前线程的访问控制上下文，以创建具有该操作中所选权限设置的线程。
    请注意，虽然在这些线程中运行的任务将具有与当前线程相同的访问控制和类加载器设置，但它们不需要具有相同的ThreadLocal或InheritableThreadLocal值。如果需要，可以在使用ThreadPoolExecutor.beforeExecute(Thread, Runnable)的ThreadPoolExecutor子类中运行任何任务之前设置或重置线程本地的特定值。此外，如果需要初始化工作线程以与其他指定的线程具有相同的InheritableThreadLocal设置，则可以创建一个自定义ThreadFactory，该线程等待和服务请求创建将继承其值的其他请求。
    
    结果
    
    线工厂
    
    异常
    
    AccessControlException - 如果当前访问控制上下文没有获取和设置上下文类加载器的权限
  - callable
```
public static <T> Callable<T> callable(Runnable task,
                                       T result)
```
    返回一个Callable对象，当被调用时，它运行给定的任务并返回给定的结果。施加需要方法时这可能是有用Callable到其他无结果的动作。
    
    参数类型
    
    T - 结果的类型
    
    参数
    
    task - 要运行的任务
    
    result - 结果返回
    
    结果
    
    可调用对象
    
    异常
    
    NullPointerException - 如果任务为空
  - callable
```
public static Callable<Object> callable(Runnable task)
```
    返回一个Callable对象，当被调用时，它运行给定的任务并返回null 。
    
    参数
    
    task - 要运行的任务
    
    结果
    
    可调用对象
    
    异常
    
    NullPointerException - 如果任务为空
  - callable
```
public static Callable<Object> callable(PrivilegedAction<?> action)
```
    返回一个Callable对象，当被调用时，它运行给定的特权动作并返回其结果。
    
    参数
    
    action - 运行的特权操作
    
    结果
    
    可调用对象
    
    异常
    
    NullPointerException - 如果动作为空
  - callable
```
public static Callable<Object> callable(PrivilegedExceptionAction<?> action)
```
    返回一个Callable对象，该对象在被调用时运行给定的特权异常操作并返回其结果。
    
    参数
    
    action - 运行的特权异常操作
    
    结果
    
    可调用对象
    
    异常
    
    NullPointerException - 如果动作为空
  - privilegedCallable
```
public static <T> Callable<T> privilegedCallable(Callable<T> callable)
```
    返回一个Callable对象，当被调用时，将在当前访问控制上下文中执行给定的callable 。通常在AccessController.doPrivileged操作中调用此方法来创建可调用的函数，如果可能的话，该方法将在该操作中保留的所选权限设置下执行; 或者如果不可能，抛出一个关联的AccessControlException 。
    
    参数类型
    
    T - 可调用结果的类型
    
    参数
    
    callable - 基础任务
    
    结果
    
    可调用对象
    
    异常
    
    NullPointerException - 如果可以调用null
  - privilegedCallableUsingCurrentClassLoader
```
public static <T> Callable<T> privilegedCallableUsingCurrentClassLoader(Callable<T> callable)
```
    返回一个Callable对象，当被调用时，将在当前访问控制上下文中执行给定的callable ，当前的上下文类加载器作为上下文类加载器。通常在AccessController.doPrivileged操作中调用此方法来创建可调用的应用程序，如果可能，在执行该操作的所选权限设置下执行; 或者如果不可能，抛出一个关联的AccessControlException 。
    
    参数类型
    
    T - 可调用结果的类型
    
    参数
    
    callable - 基础任务
    
    结果
    
    可调用对象
    
    异常
    
    NullPointerException - 如果可以调用null
    
    AccessControlException - 如果当前访问控制上下文没有设置和获取上下文类加载器的权限

Class Executors

方法摘要

Methods inherited from class java.lang.Object

方法详细信息

newFixedThreadPool

newWorkStealingPool

newWorkStealingPool

newFixedThreadPool

newSingleThreadExecutor

newSingleThreadExecutor

newCachedThreadPool

newCachedThreadPool

newSingleThreadScheduledExecutor

newSingleThreadScheduledExecutor

newScheduledThreadPool

newScheduledThreadPool

unconfigurableExecutorService

unconfigurableScheduledExecutorService

defaultThreadFactory

privilegedThreadFactory

callable

callable

callable

callable

privilegedCallable

privilegedCallableUsingCurrentClassLoader