目录

1. 为什么需要线程池？ - 理解其核心价值
2. Spring 中的线程池实现：ThreadPoolTaskExecutor - Spring Boot 的标准选择
3. 核心配置详解 - 如何配置一个高效的线程池
4. 使用方式 - 在 Spring/Spring Boot 中如何提交任务
5. 最佳实践与注意事项 - 避免踩坑
6. 高级特性：AsyncUncaughtExceptionHandler - 异常处理
7. 替代方案：@Scheduled 与线程池 - 定时任务

为什么需要线程池？

直接创建和销毁线程（new Thread()）是非常消耗资源的操作，线程池的核心思想是 “复用”。

• 降低资源消耗：通过重复利用已创建的线程,减少了线程创建和销毁造成的开销。
• 提高响应速度：当任务到达时,任务可以不需要等待创建线程就能立即执行。
• 提高线程的可管理性：线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，线程池可以进行统一的分配、调优和监控。

Spring 中的线程池实现：ThreadPoolTaskExecutor

在 Spring 生态中，我们不推荐直接使用 Java 原生的 ThreadPoolExecutor，而是使用 Spring 封装的 org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor。

为什么用 ThreadPoolTaskExecutor？

1. 与 Spring IoC 容器集成：它可以被 Spring 管理，作为 Bean 注入到其他 Bean 中，享受 Spring 的生命周期管理。
2. 支持 @Async 注解：它是 @Async 注解的默认实现,是实现异步方法调用最方便的方式。
3. 配置更简单：可以通过 XML 或 Java Config（@Bean）的方式进行优雅配置。
4. 生命周期管理：支持 @PreDestroy，在容器销毁时能优雅地关闭线程池（shutdown()）,避免任务丢失。

核心配置详解

ThreadPoolTaskExecutor 的核心配置项与 java.util.concurrent.ThreadPoolExecutor 的构造函数参数一一对应。

核心参数

Java Config 配置方式（推荐）

这是最现代、最推荐的方式，尤其适用于 Spring Boot 项目。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
@Configuration
@EnableAsync // 启用异步任务支持
public class AsyncTaskConfig {
    /**
     * 自定义线程池
     * @return
     */
    @Bean("myTaskExecutor")
    public Executor myTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程数 (根据CPU核心数来定)
        int cores = Runtime.getRuntime().availableProcessors();
        executor.setCorePoolSize(cores);
        // 最大线程数
        executor.setMaxPoolSize(cores * 2);
        // 队列容量
        executor.setQueueCapacity(100);
        // 空闲线程存活时间
        executor.setKeepAliveSeconds(60);
        // 线程名前缀
        executor.setThreadNamePrefix("my-async-task-");
        // 拒绝策略：当队列满了，由调用者所在的线程执行该任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 等待所有任务完成后再关闭线程池
        executor.setWaitForTasksToCompleteOnShutdown(true);
        // 初始化
        executor.initialize();
        return executor;
    }
}

注意：

• @EnableAsync：必须在配置类上添加此注解，才能启用 @Async 功能。
• @Bean("myTaskExecutor")：给 Bean 命名，这样在使用 @Async 时可以指定具体的线程池。

使用方式

配置好线程池后，我们就可以在代码中使用了,主要有两种方式。

@Async 注解（最常用）

这是实现异步方法调用的标准方式。

1. 创建异步服务类

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
@Service
public class AsyncService {
    // 使用默认的线程池
    @Async
    public void doSomethingDefault() {
        System.out.println("执行默认异步任务，线程名: " + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("默认异步任务执行完成");
    }
    // 使用我们自定义的名为 "myTaskExecutor" 的线程池
    @Async("myTaskExecutor")
    public void doSomethingWithMyExecutor() {
        System.out.println("执行自定义线程池异步任务，线程名: " + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("自定义线程池异步任务执行完成");
    }
}

2. 在 Controller 或其他地方调用

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class MyController {
    @Autowired
    private AsyncService asyncService;
    @GetMapping("/async")
    public String testAsync() {
        System.out.println("Controller 开始调用异步方法，主线程名: " + Thread.currentThread().getName());
        asyncService.doSomethingDefault();
        asyncService.doSomethingWithMyExecutor();
        System.out.println("Controller 调用结束，主线程继续执行。");
        return "Async tasks have been submitted!";
    }
}

执行结果分析：

• 访问 /async 接口，控制台会立即打印出 Controller 的开始和结束日志。
• 大约 2 秒后,打印出默认线程池的任务完成日志。
• 大约 3 秒后,打印出自定义线程池的任务完成日志。
• 这证明了两个异步任务确实在后台线程中并行执行,没有阻塞主线程。

直接注入并使用

你也可以直接将配置好的 Executor 注入到你的 Bean 中,然后像使用普通线程池一样提交任务。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
@Service
public class AsyncTaskService {
    // 注入我们自定义的线程池
    @Qualifier("myTaskExecutor") // 使用 @Qualifier 来指定 Bean 的名称
    @Autowired
    private Executor myTaskExecutor;
    public CompletableFuture<String> doTask() {
        System.out.println("开始执行 CompletableFuture 任务，线程名: " + Thread.currentThread().getName());
        return CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("CompletableFuture 任务执行完成，线程名: " + Thread.currentThread().getName());
            return "Task completed!";
        }, myTaskExecutor); // 指定使用哪个线程池
    }
}

这种方式更灵活，可以和 Java 8 的 CompletableFuture 结合,实现更复杂的异步编排逻辑。

最佳实践与注意事项

1. 线程池命名 (threadNamePrefix)

   • 必须设置！ 这在排查线上问题时至关重要，通过日志或线程转储,你可以清晰地知道哪个任务是由哪个业务模块的线程池执行的。

2. 拒绝策略 (rejectedExecutionHandler)

   • 切勿使用默认的 AbortPolicy (直接抛异常)，这可能导致业务中断，生产环境推荐使用 CallerRunsPolicy，让调用方线程去执行任务，虽然会慢一点，但保证了任务的最终执行,避免了任务丢失。

3. 优雅关闭 (waitForTasksToCompleteOnShutdown)

   • 在应用关闭时（如执行 kubectl delete pod 或 docker stop），Spring 容器会销毁 Bean，设置 setWaitForTasksToCompleteOnShutdown(true) 可以让线程池等待正在执行的任务完成，而不是直接粗暴地关闭,这可以防止任务执行到一半被中断。

4. 异常处理 (AsyncUncaughtExceptionHandler)

   • @Async 方法如果抛出异常，默认情况下，调用方是捕获不到的（因为它是在另一个线程中执行的），Spring 提供了 AsyncUncaughtExceptionHandler 来处理这类未被捕获的异常。

   @Configuration
   @EnableAsync
   public class AsyncTaskConfig implements AsyncConfigurer { // 实现 AsyncConfigurer 接口
       @Override
       public Executor getAsyncExecutor() {
           // ... 返回你的线程池 Bean ...
           return executor;
       }
       @Override
       public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
           return new CustomAsyncExceptionHandler();
       }
   }
   public class CustomAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
       @Override
       public void handleUncaughtException(Throwable ex, Method method, Object... params) {
           // 记录日志，发送告警等
           System.err.printf("异步方法 %s 抛出异常: %s, 参数: %s\n", method.getName(), ex.getMessage(), Arrays.toString(params));
           // 这里可以接入你的监控系统，如 Sentry, ELK 等
       }
   }

   注意：这个异常处理器只对没有返回值的 @Async 方法（即返回 void）有效，如果方法返回 Future，异常会通过 Future.get() 抛出。

5. 避免使用 @Async 的方法内部调用

   • this.asyncMethod() 不会生效，因为 Spring AOP 是通过代理实现的，代理对象无法调用自身的方法，解决方案是注入自己的代理对象：@Autowired private MyService self; self.asyncMethod();

6. 不要将 Spring Bean 作为 ThreadLocal 变量

   • ThreadLocal 中的对象是线程隔离的，但 Spring Bean 大多是单例的，如果将一个单例 Bean 放入 ThreadLocal，可能会导致数据错乱，因为不同线程会修改同一个 Bean 的状态，如果需要线程隔离的数据，请使用 InheritableThreadLocal（谨慎使用）或每次创建新对象。

高级特性：AsyncUncaughtExceptionHandler

这部分已在“最佳实践”中详细说明，它是处理 @Async 方法未捕获异常的关键。

替代方案：@Scheduled 与线程池

Spring 的定时任务 @Scheduled 默认也是在一个单线程的 ScheduledThreadPoolExecutor 中执行的，如果多个定时任务执行时间较长,可能会相互阻塞。

同样，我们可以通过配置来为 @Scheduled 指定一个独立的线程池。

1. 配置定时任务线程池

@Configuration
@EnableScheduling // 启用定时任务
public class ScheduleConfig implements SchedulingConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(taskExecutor());
    }
    @Bean(destroyMethod = "shutdown")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("scheduled-task-");
        executor.initialize();
        return executor;
    }
}

2. 使用 @Scheduled

@Component
public class MyScheduledTasks {
    @Scheduled(fixedRate = 1000) // 每秒执行一次
    public void task1() {
        System.out.println("定时任务1执行，线程名: " + Thread.currentThread().getName());
        // 模拟耗时操作
        try { Thread.sleep(500); } catch (InterruptedException e) {}
    }
    @Scheduled(fixedRate = 2000) // 每2秒执行一次
    public void task2() {
        System.out.println("定时任务2执行，线程名: " + Thread.currentThread().getName());
    }
}

task1 和 task2 会在我们配置的 scheduled-task- 线程池中并发执行,而不会互相阻塞。

最终建议：

在 Spring 项目中，始终使用 ThreadPoolTaskExecutor，通过 @Configuration + @Bean 的方式精心配置你的线程池，并牢记 命名、拒绝策略、优雅关闭 这三大要点，结合 @Async 和 @Scheduled，你可以高效、稳定地处理各种异步和定时业务场景。