Java Executor接口详解

港控/mmm° 2024-03-22 13:55 87阅读 0赞

**目录**

1、Java 中的 Executor Interfaces 类型描述

2、ExecutorService接口详解

3、ScheduledExecutorService 接口详解

--------------------

#### 1、Java 中的 Executor Interfaces 类型描述 ####

java.util.concurrent 包定义了三个执行器接口，分别为**Executor**，**ExecutorService**和**ScheduledExecutorService**

（1）**Executor**是Java中的一个接口，用于执行Runnable任务。该接口**只定义了一个方法execute(Runnable command)**，用于将任务提交到执行器中执行。Executor接口没有定义线程池的概念，因此使用Executor只能创建一个新的线程执行任务，而不能重用线程。// 基础接口

（2）在Java 5中，**Executor接口被扩展为ExecutorService接口**。ExecutorService接口继承自Executor接口，并增加了一些管理线程池的方法，例如shutdown()、submit()等。ExecutorService提供了更丰富的线程池管理功能，例如线程池大小的控制、任务队列的管理、定时任务的执行等。// 增加线程池的管理

（3）除了Executor和ExecutorService接口，Java中还提供了ScheduledExecutorService接口，用于执行定时任务和周期性任务。**ScheduledExecutorService接口继承自ExecutorService接口**，并增加了一些执行定时任务的方法，例如schedule()、scheduleAtFixedRate()等。// 增加定时任务

在Java中，可以使用**Executors类**来创建不同类型的线程池。Executors类提供了一些静态工厂方法，例如newFixedThreadPool()、newCachedThreadPool()、newSingleThreadExecutor()等，用于创建不同类型的线程池。这些方法返回的都是实现了ExecutorService接口的线程池对象。

#### 2、ExecutorService接口详解 ####

ExecutorService是Java中用于管理线程池的接口，它继承自Executor接口并扩展了一些管理线程池的方法。ExecutorService接口定义了以下方法：// 提供对线程池的管理

*  submit()：submit()方法用于提交任务到线程池中执行，并返回一个Future对象。Future对象可以用来判断任务是否完成，以及获取任务的执行结果。// 接口中新增的方法
 *  shutdown()：shutdown()方法用于关闭线程池。调用该方法后，线程池不再接收新的任务，但会将已经提交的任务继续执行直到所有任务执行完毕。
 *  shutdownNow()：shutdownNow()方法用于立即关闭线程池。调用该方法后，线程池会中断所有正在执行的任务，并返回一个列表，其中包含所有未执行的任务。
 *  isShutdown()：isShutdown()方法用于判断线程池是否已经关闭。
 *  isTerminated()：isTerminated()方法用于判断线程池中的所有任务是否已经执行完毕。
 *  awaitTermination()：awaitTermination()方法用于等待线程池中所有任务执行完毕。该方法会阻塞当前线程，直到所有任务执行完毕或等待超时。// 与shutdown()结合使用，不然会一直阻塞

除了上述方法，ExecutorService还提供了一些扩展方法，例如invokeAll()、invokeAny()、submit()等，用于提交任务和获取任务执行结果。

在使用ExecutorService时，可以通过Executors类的静态工厂方法来创建不同类型的线程池。例如，可以通过newFixedThreadPool()方法创建一个固定大小的线程池，或者通过newCachedThreadPool()方法创建一个可缓存的线程池。创建线程池后，可以使用submit()方法将任务提交到线程池中执行，也可以使用shutdown()方法关闭线程池。

下面是一个使用ExecutorService的示例代码，其中创建了一个固定大小为10的线程池，将20个任务提交到线程池中执行，并等待所有任务执行完毕后输出执行结果：

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    
    public class ExecutorServiceExample {
        public static void main(String[] args) {
            // 创建一个固定大小的线程池，大小为10
            ExecutorService executorService = Executors.newFixedThreadPool(10);
    
            // 提交20个任务到线程池中执行
            for (int i = 1; i <= 20; i++) {
                executorService.submit(new Task(i));
            }
    
            // 关闭线程池
            executorService.shutdown();
    
            // 等待所有任务执行完毕
            try {
                executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            System.out.println("All tasks completed.");
        }
    
        private static class Task implements Runnable {
            private final int taskId;
    
            public Task(int taskId) {
                this.taskId = taskId;
            }
    
            @Override
            public void run() {
                System.out.println("Task " + taskId + " is running.");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Task " + taskId + " is completed.");
            }
        }
    }

在上述代码中，创建了一个固定大小为10的线程池，将20个任务提交到线程池中执行。每个任务的执行过程是打印任务编号，睡眠1秒模拟任务执行，然后打印任务完成信息。最后使用awaitTermination()方法等待所有任务执行完毕，输出"All tasks completed."信息。

**1）awaitTermination() 方法：**

在使用ExecutorService提交任务到线程池执行时，通常需要在任务执行完毕后进行一些操作，例如收集任务的执行结果或者输出任务执行情况等。但是，当线程池中有大量任务需要执行时，可能需要等待较长时间才能完成所有任务的执行。在这种情况下，可以使用ExecutorService的awaitTermination()方法来**等待所有任务执行完毕**。

awaitTermination()方法会阻塞当前线程，直到所有任务执行完毕或等待超时。该方法接收两个参数，分别为等待时间和时间单位。如果所有任务在指定的等待时间内执行完毕，则方法返回true；否则，方法返回false。

使用awaitTermination()方法可以保证在所有任务执行完毕后再进行后续操作，避免了在任务尚未完成时进行后续操作的情况。同时，使用awaitTermination()方法还可以避免无限等待的情况，如果等待时间超过指定时间仍有任务未执行完毕，则可以结束等待并进行后续操作。

**2）shutdown()方法：**

executorService.shutdown()方法是ExecutorService接口中定义的一个方法，用于关闭线程池。**该方法会停止线程池接受新的任务，等待线程池中所有任务执行完毕后关闭线程池**。

当调用executorService.shutdown()方法时，线程池状态会变为SHUTDOWN状态。此时，线程池不再接受新的任务，但是已经提交的任务会继续执行直到执行完毕。// 中间有状态的转换

如果在线程池状态为SHUTDOWN状态时，再次提交任务，则会抛出RejectedExecutionException异常。

当线程池中所有任务执行完毕后，线程池状态会变为TERMINATED状态。此时，线程池中的所有线程都已经被销毁，线程池对象也已经无法再被使用。

需要注意的是，shutdown()方法并不会立即关闭线程池，而是等待所有任务执行完毕后再进行关闭。如果需要立即关闭线程池，可以使用shutdownNow()方法。

#### 3、ScheduledExecutorService 接口详解 ####

ScheduledExecutorService接口是继承自ExecutorService接口的一种特殊类型的线程池，它可以在给定的延迟时间之后或定期执行任务。

该接口定义了两个常用方法：

*  schedule(Runnable command, long delay, TimeUnit unit)

该方法用于在给定的延迟时间之后执行指定的任务。它接收三个参数：**要执行的任务、延迟时间**和**时间单位**。在指定的延迟时间之后，该方法会将任务提交给线程池执行。

*  scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)

该方法用于以固定的速率定期执行任务。它接收四个参数：**要执行的任务、初始延迟时间、间隔时间**和**时间单位**。在初始延迟时间之后，该方法会以固定的间隔时间重复执行任务。

除了这两个常用方法外，ScheduledExecutorService接口还提供了其他一些方法，例如scheduleWithFixedDelay()等，用于支持更加灵活的任务调度。

使用ScheduledExecutorService可以方便地执行定时任务，例如定时打印日志、定时刷新缓存等。它比[Timer类][Timer]更加灵活和可靠，因为ScheduledExecutorService使用线程池来执行任务，可以避免单个线程的阻塞影响其他任务的执行。

下面是使用ScheduledExecutorService接口进行定时任务调度的示例代码：

import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    public class ScheduledTaskExample {
    
        public static void main(String[] args) {
            ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
    
            // 任务1：在5秒后执行一次（不循环）
            Runnable task1 = () -> System.out.println("Task 1 executed");
            scheduledExecutorService.schedule(task1, 5, TimeUnit.SECONDS);
    
            // 任务2：每隔10秒执行一次（循环）
            Runnable task2 = () -> System.out.println("Task 2 executed");
            scheduledExecutorService.scheduleAtFixedRate(task2, 0, 10, TimeUnit.SECONDS);
        }
    }

在这个示例中，我们创建了一个ScheduledExecutorService实例，并使用它来执行两个不同的任务。

任务1是一个简单的Runnable实现，它会在5秒后执行一次。我们使用schedule()方法来安排它的执行，并将延迟时间设置为5秒。

任务2是一个周期性任务，它会每隔10秒执行一次。我们使用scheduleAtFixedRate()方法来安排它的执行，并将初始延迟时间设置为0，间隔时间设置为10秒。

最后，我们需要在程序结束时关闭ScheduledExecutorService实例，以释放线程资源。可以调用shutdown()方法来关闭线程池。

[Timer]: https://blog.csdn.net/swadian2008/article/details/100173207