JAVA-线程-二-ExecutorService 接口

2019-10-28 本文已影响0人 AlanSun2

ExecutorService 提供了用于终止线程的方法以及可以生成用于跟踪一个或多个异步任务进度的 Future 的方法的一个线程执行器。

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

方法提交通过创建并返回可以用于取消执行和/或等待完成的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：首先通过调用 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线程中执行的操作发生在获取任务前，获取任务发生于通过 Future.get() 获取结果前。（两个happen-before 保证）

ExecutorService 接口结构：

public interface ExecutorService extends Executor {
    //启动有序关闭，在该关闭中执行先前提交的任务，但不接受任何新任务
    void shutdown();
     //尝试停止所有正在执行的任务，暂停正在等待的任务的处理，并返回正在等待执行的任务的列表。
    List<Runnable> shutdownNow();
    
    boolean isShutdown();
    //如果所有任务在关闭后都已完成，则返回true
    boolean isTerminated();
    //阻塞直到关闭请求后所有任务完成执行，或者发生超时，或者当前线程被中断（以先发生的为准）。
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
    //提交要执行的返回值任务，并返回表示任务的未决结果的Future。
    <T> Future<T> submit(Callable<T> task);
    //提交一个Runnable任务以执行并返回一个表示该任务的Future。返回指定结果 result
    <T> Future<T> submit(Runnable task, T result);
    //提交一个Runnable任务以执行并返回一个表示该任务的Future。如果成功则返回 null
    Future<?> submit(Runnable task);
    //执行给定的任务，并在所有任务完成时返回保存其状态和结果的 Futures 列表。
    <0T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;
    //执行给定的任务，并在所有任务完成或超时到期时（以先发生者为准）返回持有其状态和结果的期货列表
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;
    //执行给定的任务，如果成功，则返回成功完成任务（即不引发异常）的结果。
    //在正常或异常返回时，尚未完成的任务将被取消。
    //如果在进行此操作时修改了给定的集合，则此方法的结果不确定。
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;
    //执行给定的任务，如果在给定的超时时间过去之前完成任务，则返回成功完成任务的结果（即没有引发异常）。
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

JAVA-线程-二-ExecutorService 接口

猜你喜欢

热点阅读