线程池的使用

最新推荐文章于 2025-10-20 12:41:25 发布

原创最新推荐文章于 2025-10-20 12:41:25 发布 · 1.9k 阅读

25 ·

CC 4.0 BY-SA版权

文章标签：

#java

1. 线程池的核心概念

线程池是一种管理多个线程的机制，通过复用线程来减少线程创建和销毁的开销，从而提高系统性能和稳定性。Java 提供了 java.util.concurrent 包来支持线程池的操作，核心类是 ThreadPoolExecutor。

2. 线程池的核心参数

创建线程池时需要指定以下核心参数：

corePoolSize：核心线程数。
maximumPoolSize：最大线程数。
keepAliveTime：非核心线程的空闲存活时间。
unit：时间单位。
workQueue：任务队列（如 LinkedBlockingQueue）。
threadFactory：线程工厂。
handler：拒绝策略（如 AbortPolicy、CallerRunsPolicy 等）。

3. 线程池的创建

Java 提供了 Executors 工厂类来创建常见的线程池：

1). newFixedThreadPool：固定大小的线程池。

创建一个固定大小的线程池，任务队列是无界的（LinkedBlockingQueue），因此理论上不会触发拒绝策略，除非线程池被关闭。
拒绝策略：默认使用 AbortPolicy，但由于队列无界，通常不会触发。

 ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);

2). newCachedThreadPool：可缓存的线程池。

创建一个可缓存的线程池，线程数可以无限增长，任务队列是同步队列（SynchronousQueue），因此当所有线程都在忙时，新任务会直接创建新线程。
拒绝策略：默认使用 AbortPolicy，但由于线程数可以无限增长，通常不会触发。

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

3). newSingleThreadExecutor：单线程的线程池。

创建一个单线程的线程池，任务队列是无界的（LinkedBlockingQueue），因此理论上不会触发拒绝策略，除非线程池被关闭。
拒绝策略：默认使用 AbortPolicy，但由于队列无界，通常不会触发。

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

4). newScheduledThreadPool：支持定时任务的线程池。

创建一个支持定时及周期性任务执行的线程池，任务队列是无界的（DelayedWorkQueue），因此理论上不会触发拒绝策略，除非线程池被关闭。
拒绝策略：默认使用 AbortPolicy，但由于队列无界，通常不会触发。

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

5). 自定义线程池：可以通过 ThreadPoolExecutor 的构造函数自定义线程池，指定核心参数和拒绝策略。

ThreadPoolExecutor customThreadPool = new ThreadPoolExecutor(
    2, // corePoolSize
    4, // maximumPoolSize
    60, // keepAliveTime
    TimeUnit.SECONDS, // unit
    new LinkedBlockingQueue<>(10), // workQueue
    Executors.defaultThreadFactory(), // threadFactory
    new ThreadPoolExecutor.AbortPolicy() // handler
);

4. 线程池的任务提交

线程池可以提交 Runnable 和 Callable 任务：

1). Runnable：无返回值，适用于不需要返回结果的任务。

run() 方法不能抛出受检异常（checked exception），只能在方法内部处理异常。
适用于不需要返回结果的任务，如日志记录、异步通知等。
可以通过 ExecutorService.submit(Runnable task) 提交任务，返回一个 Future<?> 对象，但 Future.get() 总是返回 null。

Future<?> future = executor.submit(() -> {
    System.out.println("Task is running");
});

2). Callable：有返回值，适用于需要返回结果的任务。

call() 方法可以抛出受检异常，调用者可以通过 Future.get() 方法捕获这些异常。
适用于需要返回结果的任务，如计算任务、数据库查询等。
可以通过 ExecutorService.submit(Callable task) 提交任务，返回一个 Future 对象，Future.get() 返回任务的结果。

Future<Integer> future = executor.submit(() -> {
    return 42;
});

3). Runnable 和 Callable都可以通过 Future.cancel(boolean mayInterruptIfRunning) 方法来取消任务

Future<?> future = executor.submit(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        // 任务逻辑
    }
});
future.cancel(true); // 尝试中断任务

5. 线程池的拒绝策略

当线程池遇到以下场景，无法接受新任务时，会根据设置的拒绝策略处理新任务。

线程池已关闭。
任务队列已满且线程数达到最大线程数。

Java 提供了四种内置的拒绝策略，分别位于 java.util.concurrent.ThreadPoolExecutor 类中：

AbortPolicy：抛出 RejectedExecutionException 异常。适用于需要严格处理任务提交失败的场景。
CallerRunsPolicy：由提交任务的线程自己执行任务。适用于不希望任务被丢弃的场景。
DiscardPolicy：直接丢弃任务。适用于可以接受任务丢失的场景。
DiscardOldestPolicy：丢弃队列中最旧的任务，然后重新提交新任务。适用于可以接受丢弃旧任务的场景。

除了使用内置的拒绝策略，还可以通过实现 RejectedExecutionHandler 接口来自定义拒绝策略：

public class CustomRejectionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("Task rejected: " + r.toString());
        // 自定义处理逻辑，如记录日志、重试等
    }
}

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    2, 4, 60, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(10),
    new CustomRejectionHandler()
);

for (int i = 0; i < 20; i++) {
    executor.submit(() -> {
        System.out.println("Task is running");
    });
}
executor.shutdown();