Java.util.concurrent.ExecutorService 接口

Java.util.concurrent.ExecutorService 接口是一个用于执行异步任务的框架，它提供了一组线程池的实现。不同于传统的线程 API，ExecutorService 使得任务的执行由线程的生命周期来控制。它是 Java 并发 API 的一部分，允许充分利用多个处理器来提升应用程序的性能。

接口方法

ExecutorService 接口的主要方法是 submit 和 shutdown。

submit

submit 方法用于提交一个任务到线程池中。

<T> Future<T> ExecutorService.submit(Callable<T> task);
void ExecutorService.submit(Runnable task);
<T> Future<T> ExecutorService.submit(Runnable task, T result);

返回值是一个 Future 对象，它表示一个异步完成的任务的结果。调用 Future.get() 方法将阻塞当前线程直到任务完成。

shutdown

shutdown 方法用于顺序关闭线程池。

void ExecutorService.shutdown();

调用后，线程池将不再接受新的任务，但会等待线程池中现有的任务完成。一旦完成，所有已提交的任务将被执行，然后线程将关闭。

示例

下面是一个使用 ExecutorService 接口的示例程序，它将创建一个线程池，提交三个任务，并等待它们执行完成。

import java.util.concurrent.*;

public class ExecutorServiceExample {
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Future<Integer> future1 = executorService.submit(() -> {
            System.out.println(Thread.currentThread().getName() + " starts task 1.");
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " completes task 1.");
            return 1;
        });
        Future<Integer> future2 = executorService.submit(() -> {
            System.out.println(Thread.currentThread().getName() + " starts task 2.");
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " completes task 2.");
            return 2;
        });
        Future<Integer> future3 = executorService.submit(() -> {
            System.out.println(Thread.currentThread().getName() + " starts task 3.");
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + " completes task 3.");
            return 3;
        });
        executorService.shutdown();
        System.out.println("Waiting for all tasks to complete...");
        int result1 = future1.get();
        int result2 = future2.get();
        int result3 = future3.get();
        System.out.println("Task 1 result: " + result1);
        System.out.println("Task 2 result: " + result2);
        System.out.println("Task 3 result: " + result3);
        System.out.println("All tasks completed.");
    }
}

该程序创建了一个包含两个线程的线程池，然后提交了三个大小不同的任务。执行结果如下：

pool-1-thread-1 starts task 2.
pool-1-thread-2 starts task 1.
pool-1-thread-1 completes task 2.
pool-1-thread-2 completes task 1.
pool-1-thread-1 starts task 3.
pool-1-thread-1 completes task 3.
Waiting for all tasks to complete...
Task 1 result: 1
Task 2 result: 2
Task 3 result: 3
All tasks completed.

总结

Java.util.concurrent.ExecutorService 接口是一个用于执行异步任务的框架，它提供了 submit 和 shutdown 两个核心方法。在实际应用中，使用线程池可以提高应用程序的性能和可伸缩性。