所有父级接口：: AutoCloseable , Executor

所有已知的子接口：: ScheduledExecutorService

所有已知的实现类：: AbstractExecutorService , ForkJoinPool , ScheduledThreadPoolExecutor , ThreadPoolExecutor

public interface ExecutorService extends Executor , AutoCloseable

Executor 提供管理终止的方法，以及可以生成 Future 以跟踪一个或多个异步任务进度的方法。

ExecutorService 可以关闭，这将导致它拒绝新任务。提供了两种不同的方法来关闭 ExecutorService。 shutdown() 方法将允许先前提交的任务在终止之前执行，而 shutdownNow() 方法阻止等待任务启动并尝试停止当前正在执行的任务。终止后，执行者没有正在执行的任务，没有等待执行的任务，也没有新的任务可以提交。应关闭未使用的 ExecutorService 以回收其资源。

方法 submit 通过创建并返回可用于取消执行和/或等待完成的 Future 来扩展基本方法 Executor.execute(Runnable) 。 invokeAny 和 invokeAll 方法执行最常用的批量执行形式，执行一组任务，然后等待至少一个或所有任务完成。（类 ExecutorCompletionService 可用于编写这些方法的自定义变体。）

Executors 类为该包中提供的执行程序服务提供工厂方法。

使用示例

这是一个网络服务的草图，其中线程池中的线程为传入请求提供服务。它使用预先配置的 Executors.newFixedThreadPool(int) 工厂方法：

 
 class NetworkService implements Runnable {
  private final ServerSocket serverSocket;
  private final ExecutorService pool;

  public NetworkService(int port, int poolSize)
    throws IOException {
   serverSocket = new ServerSocket(port);
   pool = Executors.newFixedThreadPool(poolSize);
  }

  public void run() { // run the service
   try {
    for (;;) {
     pool.execute(new Handler(serverSocket.accept()));
    }
   } catch (IOException ex) {
    pool.shutdown();
   }
  }
 }

 class Handler implements Runnable {
  private final Socket socket;
  Handler(Socket socket) { this.socket = socket; }
  public void run() {
   // read and service request on socket
  }
 }

也可以按如下方式建立和关闭（关闭、阻塞直到终止）一个 ExecutorService；用不同的 Executors 工厂方法进行说明：

 
 try (ExecutorService e = Executors.newWorkStealingPool()) {
  // submit or execute many tasks with e ...
 }

还可以进一步定制。例如，以下方法分两个阶段关闭 ExecutorService，首先调用 shutdown 拒绝传入任务，然后调用 shutdownNow，如有必要，取消任何延迟任务：

 
 void shutdownAndAwaitTermination(ExecutorService pool) {
  pool.shutdown(); // Disable new tasks from being submitted
  try {
   // Wait a while for existing tasks to terminate
   if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
    pool.shutdownNow(); // Cancel currently executing tasks
    // Wait a while for tasks to respond to being cancelled
    if (!pool.awaitTermination(60, TimeUnit.SECONDS))
      System.err.println("Pool did not terminate");
   }
  } catch (InterruptedException ex) {
   // (Re-)Cancel if current thread also interrupted
   pool.shutdownNow();
   // Preserve interrupt status
   Thread.currentThread().interrupt();
  }
 }

内存一致性影响：在将 Runnable 或 Callable 任务提交给 ExecutorService 发生在之前 任务之前线程中的操作发生在之前结果通过 Future.get() 检索。

自从：: 1.5

方法总结

修饰符和类型

方法

描述

boolean

awaitTermination(long timeout, TimeUnit unit)

阻塞直到所有任务在关闭请求后完成执行，或者发生超时，或者当前线程被中断，以先发生者为准。

default void

close()

启动有序关闭，其中执行先前提交的任务，但不会接受新任务。

<T> List<Future<T>>

invokeAll(Collection<? extends Callable<T>> tasks)

执行给定的任务，在所有任务完成时返回一个 Futures 列表，其中包含它们的状态和结果。

<T> List<Future<T>>

invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)

执行给定的任务，返回一个 Futures 列表，当所有任务完成或超时到期时（以先发生者为准），保存它们的状态和结果。

<T> T

invokeAny(Collection<? extends Callable<T>> tasks)

执行给定的任务，返回成功完成的任务的结果（即，没有抛出异常），如果有的话。

<T> T

invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)

执行给定的任务，返回已成功完成的任务的结果（即，没有抛出异常），如果在给定的超时结束之前有任何执行的话。

boolean

isShutdown()

如果此执行程序已关闭，则返回 true。

boolean

isTerminated()

如果关闭后所有任务都已完成，则返回 true。

void

shutdown()

启动有序关闭，其中执行先前提交的任务，但不会接受新任务。

List<Runnable>

shutdownNow()

尝试停止所有正在执行的任务，停止等待任务的处理，并返回等待执行的任务列表。

Future<?>

submit(Runnable task)

提交一个 Runnable 任务以供执行并返回一个代表该任务的 Future。

<T> Future<T>

submit(Runnable task, T result)

提交一个 Runnable 任务以供执行并返回一个代表该任务的 Future。

<T> Future<T>

submit(Callable<T> task)

提交一个有返回值的任务以供执行，并返回一个代表任务未决结果的 Future。

在接口 java.util.concurrent.Executor 中声明的方法
execute

方法详情
- shutdown
  
  void shutdown()
  
  启动有序关闭，其中执行先前提交的任务，但不会接受新任务。如果已经关闭，则调用没有额外效果。
  该方法不等待之前提交的任务完成执行。使用 awaitTermination 来做到这一点。
  
  抛出：
  
  SecurityException - 如果存在安全管理器并且关闭此 ExecutorService 可能会操作不允许调用者修改的线程，因为它不包含 RuntimePermission ("modifyThread") ，或者安全管理器的 checkAccess 方法拒绝访问。
- shutdownNow
  
  List <Runnable > shutdownNow()
  
  尝试停止所有正在执行的任务，停止等待任务的处理，并返回等待执行的任务列表。
  此方法不等待主动执行的任务终止。使用 awaitTermination 来做到这一点。
  
  除了尽最大努力停止处理正在执行的任务之外，没有任何保证。例如，典型的实现将通过 Thread.interrupt() 取消，因此任何未能响应中断的任务可能永远不会终止。
  
  返回：
  
  从未开始执行的任务列表
  
  抛出：
  
  SecurityException - 如果存在安全管理器并且关闭此 ExecutorService 可能会操作不允许调用者修改的线程，因为它不包含 RuntimePermission ("modifyThread") ，或者安全管理器的 checkAccess 方法拒绝访问。
- isShutdown
  
  boolean isShutdown()
  
  如果此执行程序已关闭，则返回 true。
  
  返回：
  
  true 如果这个执行器已经关闭
- isTerminated
  
  boolean isTerminated()
  
  如果关闭后所有任务都已完成，则返回 true。请注意，除非先调用 shutdown 或 shutdownNow，否则 isTerminated 永远不会是 true。
  
  返回：
  
  true 如果关闭后所有任务都已完成
- awaitTermination
  
  boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException
  
  阻塞直到所有任务在关闭请求后完成执行，或者发生超时，或者当前线程被中断，以先发生者为准。
  
  参数：
  
  timeout - 最长时间等待
  
  unit - 超时参数的时间单位
  
  返回：
  
  true 如果此执行程序终止，false 如果超时在终止前结束
  
  抛出：
  
  InterruptedException - 如果在等待时被打断
- submit
  
  <T> Future <T> submit(Callable <T> task)
  
  提交一个有返回值的任务以供执行，并返回一个代表任务未决结果的 Future。 Future 的 get 方法将在成功完成后返回任务结果。
  如果你想立即阻塞等待任务，你可以使用 result = exec.submit(aCallable).get(); 形式的结构
  
  注意：Executors 类包含一组方法，可以将一些其他常见的类似闭包的对象（例如，PrivilegedAction 转换为 Callable 形式）以便提交。
  
  类型参数：
  
  T - 任务结果的类型
  
  参数：
  
  task - 要提交的任务
  
  返回：
  
  代表任务未决完成的 Future
  
  抛出：
  
  RejectedExecutionException - 如果无法安排任务执行
  
  NullPointerException - 如果任务为空
- submit
  
  <T> Future <T> submit(Runnable task, T result)
  
  提交一个 Runnable 任务以供执行并返回一个代表该任务的 Future。 Future 的 get 方法将在成功完成后返回给定的结果。
  
  类型参数：
  
  T - 结果的类型
  
  参数：
  
  task - 要提交的任务
  
  result - 要返回的结果
  
  返回：
  
  代表任务未决完成的 Future
  
  抛出：
  
  RejectedExecutionException - 如果无法安排任务执行
  
  NullPointerException - 如果任务为空
- submit
  
  Future <?> submit(Runnable task)
  
  提交一个 Runnable 任务以供执行并返回一个代表该任务的 Future。 Future 的 get 方法将在 successful 完成后返回 null。
  
  参数：
  
  task - 要提交的任务
  
  返回：
  
  代表任务未决完成的 Future
  
  抛出：
  
  RejectedExecutionException - 如果无法安排任务执行
  
  NullPointerException - 如果任务为空
- invokeAll
  
  <T> List <Future <T>> invokeAll(Collection <? extends Callable <T>> tasks) throws InterruptedException
  
  执行给定的任务，在所有任务完成时返回一个 Futures 列表，其中包含它们的状态和结果。 Future.isDone() 是返回列表中每个元素的 true。请注意，completed 任务可以正常终止或通过抛出异常终止。如果在执行此操作时修改了给定的集合，则此方法的结果是未定义的。
  
  类型参数：
  
  T - 从任务返回的值的类型
  
  参数：
  
  tasks - 任务集合
  
  返回：
  
  代表任务的 Futures 列表，顺序与迭代器为给定任务列表生成的顺序相同，每个任务都已完成
  
  抛出：
  
  InterruptedException - 如果在等待时被打断，在这种情况下未完成的任务将被取消
  
  NullPointerException - 如果任务或其任何元素是 null
  
  RejectedExecutionException - 如果无法安排任何任务执行
- invokeAll
  
  <T> List <Future <T>> invokeAll(Collection <? extends Callable <T>> tasks, long timeout, TimeUnit unit) throws InterruptedException
  
  执行给定的任务，返回一个 Futures 列表，当所有任务完成或超时到期时（以先发生者为准），保存它们的状态和结果。 Future.isDone() 是返回列表中每个元素的 true。返回时，未完成的任务将被取消。请注意，completed 任务可以正常终止或通过抛出异常终止。如果在执行此操作时修改了给定的集合，则此方法的结果是未定义的。
  
  类型参数：
  
  T - 从任务返回的值的类型
  
  参数：
  
  tasks - 任务集合
  
  timeout - 最长时间等待
  
  unit - 超时参数的时间单位
  
  返回：
  
  代表任务的 Futures 列表，其顺序与迭代器为给定任务列表生成的顺序相同。如果操作没有超时，则每个任务都已完成。如果确实超时，则其中一些任务将不会完成。
  
  抛出：
  
  InterruptedException - 如果在等待时被打断，在这种情况下未完成的任务将被取消
  
  NullPointerException - 如果任务、它的任何元素或单元是 null
  
  RejectedExecutionException - 如果无法安排任何任务执行
- invokeAny
  
  <T> T invokeAny(Collection <? extends Callable <T>> tasks) throws InterruptedException , ExecutionException
  
  执行给定的任务，返回成功完成的任务的结果（即，没有抛出异常），如果有的话。在正常或异常返回时，未完成的任务将被取消。如果在执行此操作时修改了给定的集合，则此方法的结果是未定义的。
  
  类型参数：
  
  T - 从任务返回的值的类型
  
  参数：
  
  tasks - 任务集合
  
  返回：
  
  其中一项任务返回的结果
  
  抛出：
  
  InterruptedException - 如果在等待时被打断
  
  NullPointerException - 如果要执行的任务或任何元素任务是 null
  
  IllegalArgumentException - 如果任务为空
  
  ExecutionException - 如果没有任务成功完成
  
  RejectedExecutionException - 如果无法安排任务执行
- invokeAny
  
  <T> T invokeAny(Collection <? extends Callable <T>> tasks, long timeout, TimeUnit unit) throws InterruptedException , ExecutionException , TimeoutException
  
  执行给定的任务，返回已成功完成的任务的结果（即，没有抛出异常），如果在给定的超时结束之前有任何执行的话。在正常或异常返回时，未完成的任务将被取消。如果在执行此操作时修改了给定的集合，则此方法的结果是未定义的。
  
  类型参数：
  
  T - 从任务返回的值的类型
  
  参数：
  
  tasks - 任务集合
  
  timeout - 最长时间等待
  
  unit - 超时参数的时间单位
  
  返回：
  
  其中一项任务返回的结果
  
  抛出：
  
  InterruptedException - 如果在等待时被打断
  
  NullPointerException - 如果任务、单元或任何要执行的元素任务是 null
  
  TimeoutException - 如果给定超时在任何任务成功完成之前过去
  
  ExecutionException - 如果没有任务成功完成
  
  RejectedExecutionException - 如果无法安排任务执行
- close
  
  default void close()
  
  启动有序关闭，其中执行先前提交的任务，但不会接受新任务。此方法等待所有任务执行完毕且执行程序终止。
  如果在等待时被中断，此方法将停止所有正在执行的任务，就像通过调用 shutdownNow() 一样。然后它继续等待，直到所有正在执行的任务都完成。等待执行的任务不会执行。在此方法返回之前，中断状态将被重新断言。
  
  如果已经终止，则调用此方法无效。
  
  指定者：
  
  close 在接口 AutoCloseable 中
  
  实现要求：
  
  默认实现调用 shutdown() 并使用 awaitTermination 等待任务完成执行。
  
  抛出：
  
  SecurityException - 如果存在安全管理器并且关闭此 ExecutorService 可能会操作不允许调用者修改的线程，因为它不包含 RuntimePermission ("modifyThread") ，或者安全管理器的 checkAccess 方法拒绝访问。
  
  自从：
  
  19

接口 ExecutorService

使用示例

方法总结

在接口 java.util.concurrent.Executor 中声明的方法

方法详情

shutdown

shutdownNow

isShutdown

isTerminated

awaitTermination

submit

submit

submit

invokeAll

invokeAll

invokeAny

invokeAny

close