Java ExecutorService：你真的了解它吗？

时光匆匆，又来到另一个里程碑，感谢粉丝们的陪伴，有你们真好~
不水文啦，一起加油叭~

一、什么是ExecutorService？

ExecutorService 是 Java 中用来管理和执行多线程任务的一种高级工具。可以有效地管理线程的生命周期和任务的执行过程，特别是在需要处理大量并发任务时尤为有用。

生动形象的比喻，ExecutorService 就像是一个管理者，你可以把任务交给它，它会根据需要创建线程，并且确保任务按照你的要求执行。

在实际编程中，可以通过 ExecutorService 来避免直接操作线程，这样做通常更安全和更高效。

可以创建一个 ExecutorService 并告诉它需要执行的任务，ExecutorService 会根据需要创建线程，并在执行完任务后将线程回收以便重用，这样可以节省资源并提高性能。

看一个简单的例子：

假设有一个需要处理大量数据的任务，可以创建一个 ExecutorService，并告诉它希望同时执行多少个任务。ExecutorService 会根据设定的自动创建和管理线程，确保这些任务可以并发执行而不会互相干扰。这种方式比手动管理线程更容易，并且可以更好地利用计算机的多核处理能力。

// 创建一个固定大小的线程池，最多同时执行两个任务
ExecutorService executor = Executors.newFixedThreadPool(2);

// 提交两个任务给线程池执行
executor.submit(() -> {
    System.out.println("任务1 正在执行...");
    // 这里放置任务1的具体代码逻辑
});

executor.submit(() -> {
    System.out.println("任务2 正在执行...");
    // 这里放置任务2的具体代码逻辑
});

// 关闭线程池
executor.shutdown();

二、ExecutorService的核心功能

1. 创建固定大小的线程池

// 创建一个包含5个线程的固定大小线程池
ExecutorService executor = Executors.newFixedThreadPool(5); 

使用场景： 当需要限制同时执行的线程数量时，可以使用固定大小的线程池。这样可以控制并发线程数量，避免系统资源被过度消耗。

2. 创建可缓存的线程池

// 创建一个可根据需要自动扩展的线程池
ExecutorService executor = Executors.newCachedThreadPool(); 

使用场景： 当有大量短期异步任务需要处理时，可以使用可缓存线程池。它会根据任务的增加自动创建新线程，并在空闲时重用现有线程，从而提高性能。

3. 提交 Runnable 任务

executor.submit(() -> {
    System.out.println("执行任务1");
    // 这里放置任务1的具体代码逻辑
});

使用场景： 当需要执行没有返回值的简单任务时，可以提交实现了 Runnable 接口的任务。例如，清理临时文件、发送通知等异步操作。

4. 提交 Callable 任务并获取结果

Future<Integer> future = executor.submit(() -> {
    System.out.println("执行任务2");
    // 这里放置任务2的具体代码逻辑
    // 返回任务执行结果
    return fu;  
});

try {
    // 获取任务执行结果，可能会阻塞直到任务完成
    Integer result = future.get();  
    System.out.println("任务2 的结果是：" + result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

使用场景： 当需要执行有返回值的任务，并且可能需要等待任务完成后获取结果时，可以提交实现了 Callable 接口的任务，并使用 Future 对象获取任务的返回值。

扩展：

Future 接口提供了一个特殊的阻塞方法 get()，它返回 Callable 任务执行的实际结果，但如果是 Runnable 任务，则只会返回 null。

如果调用get()方法时任务仍在运行，那么调用将会一直被执阻塞，直到任务正确执行完毕并且结果可用时才返回。

get() 方法是阻塞的，而且并不知道要阻塞多长时间。因此可能导致应用程序的性能降低。如果结果数据并不重要，那么我们可以使用超时机制来避免长时间阻塞。

// 等待 200 毫秒
String result = future.get(200, TimeUnit.MILLISECONDS);

这个get() 的重载，第一个参数为超时的时间，第二个参数为时间的单位。

5. 控制线程池的关闭

// 平稳关闭线程池，等待所有任务执行完成
executor.shutdown(); 

使用场景： 当不再需要使用 ExecutorService 时，应该调用 shutdown() 方法来关闭线程池。确保已提交的任务能够完成执行，避免资源泄漏和任务丢失的问题。

三、如何创建和使用ExecutorService？

使用 Executors 工厂类来创建不同类型的 ExecutorService。

newFixedThreadPool(int n) 可以创建一个固定大小的线程池。

newCachedThreadPool() 则可以创建一个根据需要自动扩展的线程池。

实际案例：

创建一个简单的多线程程序，使用 ExecutorService 执行一批任务，并获取它们的执行结果。

public static void main(String[] args) {
        // 创建一个固定大小为3的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 创建一个列表来保存提交的任务
        List<Future<Integer>> futures = new ArrayList<>();

        // 提交10个任务，每个任务返回任务ID乘以2的结果
        for (int i = 1; i <= 10; i++) {
            final int taskId = i;
            // 提交 Callable 任务，并将 Future 对象保存到列表中
            Future<Integer> future = executor.submit(() -> {
                System.out.println("任务 " + taskId + " 开始执行");
                // 模拟任务执行耗时
                Thread.sleep(2000);  
                // 返回任务的结果
                return taskId * 2;   
            });
            // 将 Future 对象添加到列表中
            futures.add(future);  
        }

        // 等待所有任务完成，并打印各任务的执行结果
        for (Future<Integer> future : futures) {
            try {
                // 获取任务执行结果，可能会阻塞直到任务完成
                Integer result = future.get();  
                System.out.println("任务结果: " + result);
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }

        // 关闭线程池
        executor.shutdown();
    }

// 输出结果
任务 1 开始执行
任务 2 开始执行
任务 3 开始执行
任务结果: 2
任务结果: 4
任务 4 开始执行
任务结果: 6
任务 5 开始执行
任务结果: 8
任务 6 开始执行
任务结果: 10
任务 7 开始执行
任务结果: 12
任务 8 开始执行
任务结果: 14
任务 9 开始执行
任务结果: 16
任务 10 开始执行
任务结果: 18
任务结果: 20

时间不能增添一个人的生命，然而珍惜光阴却可使生命变得更有价值