compact1, compact2, compact3

java.util.concurrent

Interface ExecutorService

All Superinterfaces:

Executor

All Known Subinterfaces:

ScheduledExecutorService

所有已知实现类：

AbstractExecutorService， ForkJoinPool， ScheduledThreadPoolExecutor， ThreadPoolExecutor

public interface ExecutorService
extends Executor

一个 Executor，管理终端和方法可以用于跟踪一个或多个异步任务的进展产生 Future提供方法。

一个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() { // 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两阶段，通过调用 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 ie) {
     // (Re-)Cancel if current thread also interrupted
     pool.shutdownNow();
     // Preserve interrupt status
     Thread.currentThread().interrupt();
   }
 }

内存一致性效果：在一个Runnable或Callable任务提交之前的一个ExecutorService happen-before任何行动采取行动任务的线程，从而发生过结果将通过Future.get()。

从以下版本开始：

一点五

方法摘要

Modifier and Type	Method and Description
boolean	awaitTermination(long timeout, TimeUnit unit) 直到所有的任务都完成后，关闭请求，或超时发生，或当前线程被中断，以先发生的情况。
<T> List<Future<T>>	invokeAll(Collection<? extends Callable<T>> tasks) 执行给定的任务，返回一个未来持有他们的状态和结果的列表时，所有的完整。
<T> List<Future<T>>	invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) 执行给定的任务，返回一个未来持有他们的状态和结果的列表时，所有的完成或超时到期，以先发生的。
<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() 试图阻止所有积极执行任务，停止等待任务的处理，并返回一个列表，正在等待执行的任务。
<T> Future<T>	submit(Callable<T> task) 提交一个值返回任务执行，并返回一个表示任务挂起结果的未来。
Future<?>	submit(Runnable task) 提交执行一个Runnable任务并返回一个表示该任务的未来。
<T> Future<T>	submit(Runnable task, T result) 提交执行一个Runnable任务并返回一个表示该任务的未来。

Methods inherited from interface java.util.concurrent.Executor

execute

方法详细信息

shutdown

void shutdown()

启动一个有序的关机，在以前提交的任务被执行，但没有新的任务将被接受。如果已经关闭调用没有额外的效果。

此方法不等待先前提交的任务以完成执行。使用awaitTermination做。

异常

SecurityException -如果存在一个安全管理和关闭这个服务可能操纵线程允许修改因为它不拥有 RuntimePermission ("modifyThread")不来电，或安全经理的 checkAccess方法拒绝访问。

shutdownNow

List<Runnable> shutdownNow()

试图阻止所有积极执行任务，停止等待任务的处理，并返回一个列表，正在等待执行的任务。

此方法不等待主动执行任务终止。使用awaitTermination做。

有没有保证超出了最好的努力试图停止处理积极执行任务。例如，典型的实现将取消通过Thread.interrupt()，所以任何任务的失败中断可能永远不会结束。

结果

未开始执行的任务列表

异常

SecurityException -如果存在一个安全管理和关闭这个服务可能操纵线程允许修改因为它不拥有 RuntimePermission ("modifyThread")不来电，或安全经理的 checkAccess方法拒绝访问。

isShutdown

boolean isShutdown()

返回 true如果执行器已关闭。

结果

true如果执行器已关闭

isTerminated

boolean isTerminated()

返回 true如果所有任务都完成后，关闭。注意， isTerminated从不 true除非 shutdown或 shutdownNow被称为第一。

结果

true如果所有任务都完成后关闭

awaitTermination

boolean awaitTermination(long timeout,
                         TimeUnit unit)
                  throws InterruptedException

直到所有的任务都完成后，关闭请求，或超时发生，或当前线程被中断，以先发生的情况。

参数

timeout -最大等待时间

unit - timeout参数的时间单位

结果

true如果执行终止和 false如果超时后终止

异常

InterruptedException如果中断等待

submit

<T> Future<T> submit(Callable<T> task)

提交一个值返回任务执行，并返回一个表示任务挂起结果的未来。未来的 get方法将返回的结果在成功完成的任务。

如果你想立即阻塞等待一个任务，你可以使用表格result = exec.submit(aCallable).get();结构

注：本Executors类包含一组方法，可以将其他一些常见的闭合状物体，例如，PrivilegedAction到Callable形式可以提交。

参数类型

T -任务类型结果

参数

task -任务提交

结果

一个即将完成的任务的未来

异常

RejectedExecutionException如果任务不能按计划执行

NullPointerException -如果任务是空的

submit

<T> Future<T> submit(Runnable task,
                     T result)

提交执行一个Runnable任务并返回一个表示该任务的未来。未来的 get方法将给定的结果成功完成后返回。

参数类型

T -结果的类型

参数

task -任务提交

result -结果返回

结果

一个即将完成的任务的未来

异常

RejectedExecutionException如果任务不能按计划执行

NullPointerException -如果任务是空的

submit

Future<?> submit(Runnable task)

提交执行一个Runnable任务并返回一个表示该任务的未来。未来的 get方法将返回 null在成功完成。

参数

task -任务提交

结果

一个即将完成的任务的未来

异常

RejectedExecutionException如果任务不能按计划执行

NullPointerException -如果任务是空的

invokeAll

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
                       throws InterruptedException

执行给定的任务，返回一个未来持有他们的状态和结果的列表时，所有的完整。 Future.isDone()是 true为返回的列表中的每个元素。请注意，一个完成的任务可能会被终止或通过抛出一个异常。此方法的结果是不确定的，如果给定的集合被修改，而这个操作正在进行中。

参数类型

T -值的类型从任务返回

参数

tasks -任务的集合

结果

一个代表任务的期货列表，在给定的任务列表的迭代器所产生的相同的顺序顺序中，每一个都完成了

异常

InterruptedException如果中断而等待，在这种情况下，未完成的任务被取消

NullPointerException如果任务或其任何元素 null

RejectedExecutionException -如果任何任务不能按计划执行

invokeAll

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

执行给定的任务，返回一个未来持有他们的状态和结果的列表时，所有的完成或超时到期，以先发生的。 Future.isDone()为返回的列表中的每个元素 true。返回后，未完成的任务被取消。请注意，一个完成的任务可能会被终止或通过抛出一个异常。此方法的结果是不确定的，如果给定的集合被修改，而这个操作正在进行中。

参数类型

T -值的类型从任务返回

参数

tasks -任务的集合

timeout -最大等待时间

unit - timeout参数的时间单位

结果

在给定任务列表中的迭代器所产生的相同顺序顺序中的一个表示任务的列表。如果操作没有超时，每个任务都将完成。如果它确实有时间，一些这些任务将不会完成。

异常

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 - timeout参数的时间单位

结果

任务由一个返回的结果

异常

InterruptedException如果中断等待

NullPointerException如果任务，或单位，或任何元素的任务被执行 null

TimeoutException -如果超时之前经过的任何任务圆满完成

ExecutionException -如果没有任务圆满完成

RejectedExecutionException如果任务不能按计划执行