ExecutorService

public interface ExecutorService
implements Executor

Known Indirect Subclasses AbstractExecutorService, ForkJoinPool, ScheduledExecutorService, ScheduledThreadPoolExecutor, ThreadPoolExecutor AbstractExecutorService 提供 ExecutorService执行方法的默认实现。 ForkJoinPool 一个 ExecutorService运行 ForkJoinTask秒。 ScheduledExecutorService 一个 ExecutorService ，可以安排命令在给定的延迟后运行，或定期执行。 ScheduledThreadPoolExecutor 一个 ThreadPoolExecutor ，可以额外安排命令在给定的延迟后运行，或定期执行。 ThreadPoolExecutor 使用 Executors工厂方法可能执行每个提交的任务的一个 ExecutorService ，可能使用几个联合线程之一。

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

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

方法submit延伸的基方法execute(Runnable)通过创建并返回一个Future可用于取消执行和/或等待完成。 方法invokeAny和invokeAll执行最常用的批量执行形式，执行任务集合，然后等待至少一个或全部完成。 （ ExecutorCompletionService类可用于编写这些方法的定制变体。）

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

Usage Examples

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

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

Summary

Inherited methods
From interface java.util.concurrent.Executor abstract void execute(Runnable command) 将来在某个时间执行给定的命令。

Public methods

boolean awaitTermination (long timeout, 
                TimeUnit unit)

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

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

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

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

boolean isShutdown ()

boolean isTerminated ()

void shutdown ()

List<Runnable> shutdownNow ()

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

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

Future<?> submit (Runnable task)