Java Executor Service 全面解析
简介
在 Java 编程中，多线程编程是一项非常重要的技能，它能显著提升程序的性能和响应能力。而 Executor Service 是 Java 并发包 java.util.concurrent 中一个关键的组件，它提供了一种高效管理和执行线程的方式。本文将深入探讨 Executor Service 的基础概念、使用方法、常见实践以及最佳实践，帮助读者更好地掌握并运用这一强大工具。
目录
- 基础概念
- 使用方法
- 常见实践
- 最佳实践
- 小结
- 参考资料
基础概念
什么是 Executor Service
Executor Service 是一个接口，它继承自 Executor 接口。Executor 是一个简单的任务执行器，它定义了一个 execute(Runnable command) 方法，用于执行一个 Runnable 任务。而 Executor Service 在此基础上提供了更丰富的功能，如任务提交、线程池管理、任务生命周期管理等。
线程池
线程池是 Executor Service 的核心概念之一。线程池是一组预先创建的线程，它们可以重复使用来执行多个任务。使用线程池的好处包括：
- 减少线程创建和销毁的开销，提高性能。
- 控制并发线程的数量，避免资源耗尽。
- 提高系统的稳定性和可管理性。
常见的 Executor Service 实现类
ThreadPoolExecutor：这是最常用的线程池实现类，它允许你自定义线程池的核心线程数、最大线程数、线程空闲时间等参数。ScheduledThreadPoolExecutor：继承自ThreadPoolExecutor，用于执行定时任务和周期性任务。Executors工具类：提供了一些静态工厂方法，用于创建常见配置的线程池，如newFixedThreadPool、newCachedThreadPool、newSingleThreadExecutor等。
使用方法
创建线程池
可以使用 Executors 工具类来创建不同类型的线程池，示例代码如下：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorServiceExample {
public static void main(String[] args) {
// 创建一个固定大小的线程池，包含 3 个线程
ExecutorService executorService = Executors.newFixedThreadPool(3);
// 创建一个可缓存的线程池
// ExecutorService executorService = Executors.newCachedThreadPool();
// 创建一个单线程的线程池
// ExecutorService executorService = Executors.newSingleThreadExecutor();
// 执行任务
for (int i = 0; i < 5; i++) {
final int taskId = i;
executorService.submit(() -> {
System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task " + taskId + " is completed.");
});
}
// 关闭线程池
executorService.shutdown();
}
}
提交任务
Executor Service 提供了两种提交任务的方法：
- execute(Runnable command)：用于提交一个 Runnable 任务，没有返回值。
- submit(Callable<T> task) 或 submit(Runnable task)：submit 方法可以接受 Runnable 或 Callable 任务，并且可以返回一个 Future 对象，用于获取任务的执行结果。示例代码如下：
import java.util.concurrent.*;
public class SubmitTaskExample {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(2);
// 提交一个 Callable 任务
Future<Integer> future = executorService.submit(() -> {
System.out.println("Callable task is running.");
Thread.sleep(2000);
return 42;
});
// 获取任务的执行结果
Integer result = future.get();
System.out.println("Callable task result: " + result);
// 提交一个 Runnable 任务
Future<?> runnableFuture = executorService.submit(() -> {
System.out.println("Runnable task is running.");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
// 检查任务是否完成
if (runnableFuture.isDone()) {
System.out.println("Runnable task is completed.");
}
executorService.shutdown();
}
}
关闭线程池
当不再需要线程池时，应该及时关闭它，以释放资源。可以使用以下两种方法关闭线程池：
- shutdown()：该方法会平滑地关闭线程池，它会拒绝新的任务提交，并等待已经提交的任务执行完毕。
- shutdownNow()：该方法会尝试立即停止所有正在执行的任务，并返回等待执行的任务列表。
常见实践
执行定时任务
使用 ScheduledThreadPoolExecutor 可以执行定时任务和周期性任务，示例代码如下：
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);
// 延迟 2 秒后执行任务
scheduledExecutorService.schedule(() -> {
System.out.println("Scheduled task is running.");
}, 2, TimeUnit.SECONDS);
// 延迟 1 秒后开始执行任务，然后每隔 3 秒执行一次
scheduledExecutorService.scheduleAtFixedRate(() -> {
System.out.println("Periodic task is running.");
}, 1, 3, TimeUnit.SECONDS);
// 关闭线程池
// scheduledExecutorService.shutdown();
}
}
批量执行任务
可以使用 invokeAll 方法批量执行多个任务，并等待所有任务完成，示例代码如下：
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
public class BatchTaskExample {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = Executors.newFixedThreadPool(3);
List<Callable<Integer>> tasks = new ArrayList<>();
for (int i = 0; i < 5; i++) {
final int taskId = i;
tasks.add(() -> {
System.out.println("Task " + taskId + " is running.");
Thread.sleep(1000);
return taskId * 2;
});
}
// 批量执行任务
List<Future<Integer>> futures = executorService.invokeAll(tasks);
// 获取所有任务的执行结果
for (Future<Integer> future : futures) {
Integer result = future.get();
System.out.println("Task result: " + result);
}
executorService.shutdown();
}
}
最佳实践
避免使用 Executors 工具类创建线程池
虽然 Executors 工具类提供了方便的线程池创建方法，但在生产环境中应尽量避免使用。因为这些方法创建的线程池可能会导致资源耗尽问题，例如 newCachedThreadPool 可能会创建大量的线程，newFixedThreadPool 和 newSingleThreadExecutor 使用的是无界队列，可能会导致内存溢出。建议直接使用 ThreadPoolExecutor 来创建线程池，示例代码如下：
import java.util.concurrent.*;
public class CustomThreadPoolExample {
public static void main(String[] args) {
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, // 核心线程数
5, // 最大线程数
60, // 线程空闲时间
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(10) // 任务队列
);
// 执行任务
for (int i = 0; i < 5; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.println("Task " + taskId + " is running.");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task " + taskId + " is completed.");
});
}
executor.shutdown();
}
}
合理配置线程池参数
根据应用的特点和需求，合理配置线程池的核心线程数、最大线程数、任务队列等参数。例如，对于 CPU 密集型任务，核心线程数可以设置为 CPU 核心数 + 1；对于 IO 密集型任务，核心线程数可以设置得更大一些。
处理任务异常
在任务执行过程中，可能会抛出异常。应该在任务中捕获并处理这些异常，或者使用 Future 对象的 get 方法获取任务执行结果时捕获 ExecutionException 异常。
小结
Executor Service 是 Java 并发编程中一个非常强大的工具，它提供了高效的线程管理和任务执行机制。通过本文的介绍，我们了解了 Executor Service 的基础概念、使用方法、常见实践以及最佳实践。在实际开发中，应该根据具体需求合理使用 Executor Service，并遵循最佳实践原则，以提高程序的性能和稳定性。
参考资料
- 《Effective Java》
- 《Java 并发编程实战》