模块  java.base
软件包  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两个阶段关闭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()检索结果之前 。

    从以下版本开始：
    1.5

    • 方法摘要

      所有方法  实例方法 抽象方法 
      变量和类型 方法 描述
      boolean awaitTermination​(long timeout, TimeUnit unit)
      阻止所有任务在关闭请求之后完成执行，或发生超时，或者当前线程被中断，以先发生者为准。
      <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。

    • 方法详细信息

      • 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 。 请注意， isTerminated永远不会是true除非先调用shutdown或shutdownNow 。
        结果
        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();表单的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's get方法将在成功完成后返回给定结果。
        参数类型
        T - 结果的类型
        参数
        task - 要提交的任务
        result - 返回的结果
        结果
        表示未完成任务的Future
        异常
        RejectedExecutionException - 如果无法安排任务执行
        NullPointerException - 如果任务为空

      • submit

        Future<?> submit​(Runnable task)
        提交Runnable任务以执行并返回表示该任务的Future。 成功完成后，Future的get方法将返回null 。
        参数
        task - 要提交的任务
        结果
        表示未完成任务的Future
        异常
        RejectedExecutionException - 如果无法安排任务执行
        NullPointerException - 如果任务为空

      • invokeAll

        <T> List<Future<T>> invokeAll​(Collection<? extends Callable<T>> tasks)
                       throws InterruptedException
        执行给定的任务，返回完成所有状态和结果的Futures列表。 对于返回列表的每个元素， Future.isDone()是true 。 请注意，已完成的任务可能正常终止或通过抛出异常终止。 如果在此操作正在进行时修改了给定集合，则此方法的结果未定义。
        参数类型
        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 。 返回后，未完成的任务将被取消。 请注意，已完成的任务可能正常终止或通过抛出异常终止。 如果在此操作正在进行时修改了给定集合，则此方法的结果未定义。
        参数类型
        T - 从任务返回的值的类型
        参数
        tasks - 任务集合
        timeout - 等待的最长时间
        unit - 超时参数的时间单位
        结果
        表示任务的Futures列表，其顺序与迭代器为给定任务列表生成的顺序相同。 如果操作没有超时，则每个任务都将完成。 如果确实超时，其中一些任务将无法完成。
        异常
        InterruptedException - 如果在等待时中断，则在此情况下取消未完成的任务
        NullPointerException - 如果任务，其任何元素或单位是 null
        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 - 如果在任何任务成功完成之前 TimeoutException了给定的超时
        ExecutionException - 如果没有任务成功完成
        RejectedExecutionException - if tasks cannot be scheduled for execution