所有超接口:: AutoCloseable, Executor

所有已知子接口:: ScheduledExecutorService

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

public interface ExecutorService extends Executor, AutoCloseable

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

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

方法 submit 扩展了基本方法 Executor.execute(Runnable)，通过创建并返回一个可以用于取消执行和/或等待完成的 Future。方法 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() { // 运行服务
     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() {
     // 在套接字上读取和处理请求
   }
 }

也可以建立并关闭 ExecutorService（关闭，阻塞直到终止）如下; 用不同的 Executors 工厂方法进行说明:

 
 try (ExecutorService e =  Executors.newWorkStealingPool()) {
   // 使用 e 提交或执行多个任务...
 }

进一步的定制也是可能的。例如，以下方法以两个阶段关闭 ExecutorService，首先通过调用 shutdown 拒绝传入任务，然后如有必要调用 shutdownNow 取消任何挂起任务:

 
 void shutdownAndAwaitTermination(ExecutorService pool) {
   pool.shutdown(); // 禁用提交新任务
   try {
     // 等待现有任务终止一段时间
     if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
       pool.shutdownNow(); // 取消当前正在执行的任务
       // 等待任务响应被取消
       if (!pool.awaitTermination(60, TimeUnit.SECONDS))
           System.err.println("池未终止");
     }
   } catch (InterruptedException ex) {
     // 如果当前线程也被中断，则（重新）取消
     pool.shutdownNow();
     // 保留中断状态
     Thread.currentThread().interrupt();
   }
 }

内存一致性效果: 在将 Runnable 或 Callable 任务提交给 ExecutorService 之前的线程中的操作 发生在 该任务执行的任何操作之前，而这些操作又在通过 Future.get() 检索结果之前发生。

自 JDK 版本:: 1.5

Method Summary

Modifier and Type

Method

Description

boolean

awaitTermination(long timeout, TimeUnit unit)

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

default void

close()

启动一个有序关闭，先前提交的任务将被执行，但不会接受新任务。

<T> List<Future<T>>

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

执行给定的任务，返回一个持有它们状态和结果的 Future 列表，当所有任务完成时。

<T> List<Future<T>>

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

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

<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。

Methods declared in interface java.util.concurrent.Executor
execute

Method Details
- 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 - 如果任务为null
- submit
  
  <T> Future<T> submit(Runnable task, T result)
  
  提交一个Runnable任务以供执行，并返回代表该任务的Future。Future的get方法将在成功完成时返回给定的结果。
  
  类型参数：
  
  T - 结果的类型
  
  参数：
  
  task - 要提交的任务
  
  result - 要返回的结果
  
  返回：
  
  代表任务挂起完成的Future
  
  抛出：
  
  RejectedExecutionException - 如果无法安排任务执行
  
  NullPointerException - 如果任务为null
- submit
  
  Future<?> submit(Runnable task)
  
  提交一个Runnable任务以供执行，并返回代表该任务的Future。Future的get方法将在成功完成时返回null。
  
  参数：
  
  task - 要提交的任务
  
  返回：
  
  代表任务挂起完成的Future
  
  抛出：
  
  RejectedExecutionException - 如果无法安排任务执行
  
  NullPointerException - 如果任务为null
- invokeAll
  
  <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException
  
  执行给定的任务，返回一个Future列表，其中包含它们的状态和结果，当所有任务都完成时。对于返回列表的每个元素，Future.isDone()都为true。请注意，已完成的任务可能已正常终止，也可能通过抛出异常终止。如果在此操作进行时修改了给定的集合，则此方法的结果是未定义的。
  
  类型参数：
  
  T - 从任务返回的值的类型
  
  参数：
  
  tasks - 任务集合
  
  返回：
  
  一个Future列表，代表任务，与给定任务列表的迭代器产生的顺序相同，每个任务都已完成
  
  抛出：
  
  InterruptedException - 如果在等待时被中断，此时未完成的任务将被取消
  
  NullPointerException - 如果任务或其任何元素为null
  
  RejectedExecutionException - 如果任何任务无法安排执行
- invokeAll
  
  <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException
  
  执行给定的任务，返回一个Future列表，其中包含它们的状态和结果，当所有任务完成或超时到期时，以先发生者为准。对于返回列表的每个元素，Future.isDone()都为true。返回后，未完成的任务将被取消。请注意，已完成的任务可能已正常终止，也可能通过抛出异常终止。如果在此操作进行时修改了给定的集合，则此方法的结果是未定义的。
  
  类型参数：
  
  T - 从任务返回的值的类型
  
  参数：
  
  tasks - 任务集合
  
  timeout - 等待的最长时间
  
  unit - 超时参数的时间单位
  
  返回：
  
  一个Future列表，代表任务，与给定任务列表的迭代器产生的顺序相同。如果操作未超时，每个任务都将已完成。如果操作超时，其中一些任务将未完成。
  
  抛出：
  
  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

Interface ExecutorService

使用示例

Method Summary

Methods declared in interface java.util.concurrent.Executor

Method Details

shutdown

shutdownNow

isShutdown

isTerminated

awaitTermination

submit

submit

submit

invokeAll

invokeAll

invokeAny

invokeAny

close