一文带你了解Java线程池

-1

原创已于 2025-08-27 10:53:39 修改 · 1.1k 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

于 2025-08-25 10:30:45 首次发布

java 同时被 2 个专栏收录

18 篇文章

订阅专栏

线程池

1 篇文章

订阅专栏

该文章已生成可运行项目，

Java线程池完整指南

线程池简介

什么是线程池

线程池是一种线程管理机制，它预先创建一定数量的线程，放入线程池中，当需要执行任务时，从线程池中获取线程来执行任务，任务执行完毕后，线程不会被销毁，而是重新放回线程池中，等待下一个任务。

线程池的优势

线程池优势:
  - 降低资源消耗: 重复利用已创建的线程，减少线程创建和销毁的开销
  - 提高响应速度: 任务到达时，线程已存在，无需等待线程创建
  - 提高线程的可管理性: 统一管理、分配、调优线程
  - 提供更多更强大的功能: 定时执行、定期执行、并发数控制等

线程池核心参数

核心参数:
  corePoolSize: 核心线程数，线程池中会维护的最小线程数量
  maximumPoolSize: 最大线程数，线程池中允许的最大线程数量
  keepAliveTime: 线程空闲时间，超过核心线程数的线程在空闲时的存活时间
  workQueue: 工作队列，用于存储等待执行的任务
  threadFactory: 线程工厂，用于创建新线程
  rejectedExecutionHandler: 拒绝策略，当线程池和队列都满了时的处理策略

线程池架构图

整体架构

任务执行流程

线程生命周期

线程池类型

1. FixedThreadPool (固定线程池)

基本使用

@Service
public class FixedThreadPoolService {
  
    // 创建固定线程池，线程数量固定为5
    private final ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
  
    public void processTasks(List<Runnable> tasks) {
        List<Future<?>> futures = new ArrayList<>();
      
        // 提交所有任务
        for (Runnable task : tasks) {
            Future<?> future = fixedThreadPool.submit(task);
            futures.add(future);
        }
      
        // 等待所有任务完成
        for (Future<?> future : futures) {
            try {
                future.get(); // 阻塞等待任务完成
            } catch (Exception e) {
                log.error("任务执行失败", e);
            }
        }
    }
  
    public void shutdown() {
        fixedThreadPool.shutdown();
        try {
            if (!fixedThreadPool.awaitTermination(60, TimeUnit.SECONDS)) {
                fixedThreadPool.shutdownNow();
            }
        } catch (InterruptedException e) {
            fixedThreadPool.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

实际应用示例

@Component
public class ImageProcessor {
  
    private final ExecutorService imageProcessPool = Executors.newFixedThreadPool(4);
  
    public List<String> processImages(List<Image> images) {
        List<Future<String>> futures = new ArrayList<>();
      
        for (Image image : images) {
            Future<String> future = imageProcessPool.submit(() -> {
                try {
                    // 模拟图片处理
                    Thread.sleep(1000);
                    return "Processed: " + image.getName();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return "Failed: " + image.getName();
                }
            });
            futures.add(future);
        }
      
        // 收集处理结果
        List<String> results = new ArrayList<>();
        for (Future<String> future : futures) {
            try {
                results.add(future.get(5, TimeUnit.SECONDS)); // 设置超时时间
            } catch (Exception e) {
                log.error("图片处理超时或失败", e);
                results.add("Error: processing failed");
            }
        }
      
        return results;
    }
}

2. CachedThreadPool (缓存线程池)

基本使用

@Service
public class CachedThreadPoolService {
  
    // 创建缓存线程池，线程数量根据任务动态调整
    private final ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
  
    public void executeShortTasks(List<Runnable> tasks) {
        CountDownLatch latch = new CountDownLatch(tasks.size());
      
        for (Runnable task : tasks) {
            cachedThreadPool.submit(() -> {
                try {
                    task.run();
                } finally {
                    latch.countDown();
                }
            });
        }
      
        try {
            // 等待所有任务完成，最多等待30秒
            latch.await(30, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
  
    public <T> List<T> executeCallableTasks(List<Callable<T>> tasks) {
        List<Future<T>> futures = new ArrayList<>();
      
        for (Callable<T> task : tasks) {
            futures.add(cachedThreadPool.submit(task));
        }
      
        List<T> results = new ArrayList<>();
        for (Future<T> future : futures) {
            try {
                results.add(future.get());
            } catch (Exception e) {
                log.error("任务执行失败", e);
            }
        }
      
        return results;
    }
}

实际应用示例

@Component
public class HttpRequestProcessor {
  
    private final ExecutorService httpRequestPool = Executors.newCachedThreadPool();
  
    public List<String> processHttpRequests(List<String> urls) {
        List<Future<String>> futures = new ArrayList<>();
      
        for (String url : urls) {
            Future<String> future = httpRequestPool.submit(() -> {
                try {
                    // 模拟HTTP请求
                    Thread.sleep(500);
                    return "Response from: " + url;
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return "Error: " + url;
                }
            });
            futures.add(future);
        }
      
        // 处理结果
        List<String> responses = new ArrayList<>();
        for (Future<String> future : futures) {
            try {
                responses.add(future.get(10, TimeUnit.SECONDS));
            } catch (Exception e) {
                log.error("HTTP请求处理失败", e);
                responses.add("Request failed");
            }
        }
      
        return responses;
    }
}

3. SingleThreadExecutor (单线程池)

基本使用

@Service
public class SingleThreadExecutorService {
  
    // 创建单线程池，保证任务顺序执行
    private final ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
  
    public void executeSequentially(List<Runnable> tasks) {
        for (Runnable task : tasks) {
            singleThreadExecutor.submit(() -> {
                try {
                    task.run();
                } catch (Exception e) {
                    log.error("顺序任务执行失败", e);
                }
            });
        }
    }
  
    public <T> List<T> executeSequentiallyWithResults(List<Callable<T>> tasks) {
        List<T> results = new ArrayList<>();
      
        for (Callable<T> task : tasks) {
            try {
                Future<T> future = singleThreadExecutor.submit(task);
                T result = future.get();
                results.add(result);
            } catch (Exception e) {
                log.error("顺序任务执行失败", e);
            }
        }
      
        return results;
    }
}

实际应用示例

@Component
public class OrderProcessor {
  
    private final ExecutorService orderProcessPool = Executors.newSingleThreadExecutor();
  
    public void processOrder(Order order) {
        orderProcessPool.submit(() -> {
            try {
                // 1. 验证订单
                validateOrder(order);
              
                // 2. 检查库存
                checkInventory(order);
              
                // 3. 扣减库存
                deductInventory(order);
              
                // 4. 创建支付订单
                createPaymentOrder(order);
              
                // 5. 更新订单状态
                updateOrderStatus(order, "PROCESSED");
              
                log.info("订单处理完成: {}", order.getId());
              
            } catch (Exception e) {
                log.error("订单处理失败: {}", order.getId(), e);
                updateOrderStatus(order, "FAILED");
            }
        });
    }
  
    private void validateOrder(Order order) {
        // 实现订单验证逻辑
        log.info("验证订单: {}", order.getId());
    }
  
    private void checkInventory(Order order) {
        // 实现库存检查逻辑
        log.info("检查库存: {}", order.getId());
    }
  
    private void deductInventory(Order order) {
        // 实现库存扣减逻辑
        log.info("扣减库存: {}", order.getId());
    }
  
    private void createPaymentOrder(Order order) {
        // 实现支付订单创建逻辑
        log.info("创建支付订单: {}", order.getId());
    }
  
    private void updateOrderStatus(Order order, String status) {
        // 实现订单状态更新逻辑
        log.info("更新订单状态: {} -> {}", order.getId(), status);
    }
}

4. ScheduledThreadPool (定时线程池)

基本使用

@Service
public class ScheduledThreadPoolService {
  
    // 创建定时线程池，支持定时和周期性任务
    private final ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(3);
  
    public void scheduleTask(Runnable task, long delay, TimeUnit unit) {
        scheduledExecutor.schedule(task, delay, unit);
    }
  
    public void scheduleAtFixedRate(Runnable task, long initialDelay, long period, TimeUnit unit) {
        scheduledExecutor.scheduleAtFixedRate(task, initialDelay, period, unit);
    }
  
    public void scheduleWithFixedDelay(Runnable task, long initialDelay, long delay, TimeUnit unit) {
        scheduledExecutor.scheduleWithFixedDelay(task, initialDelay, delay, unit);
    }
  
    public ScheduledFuture<?> scheduleWithReturn(Runnable task, long delay, TimeUnit unit) {
        return scheduledExecutor.schedule(task, delay, unit);
    }
}

实际应用示例

@Component
public class TaskScheduler {
  
    private final ScheduledExecutorService taskScheduler = Executors.newScheduledThreadPool(5);
  
    @PostConstruct
    public void initScheduledTasks() {
        // 延迟5秒后执行一次
        scheduleOneTimeTask();
      
        // 每1分钟执行一次（固定频率）
        scheduleFixedRateTask();
      
        // 每2分钟执行一次（固定延迟）
        scheduleFixedDelayTask();
      
        // 每天凌晨2点执行
        scheduleDailyTask();
    }
  
    private void scheduleOneTimeTask() {
        taskScheduler.schedule(() -> {
            log.info("一次性任务执行: {}", LocalDateTime.now());
        }, 5, TimeUnit.SECONDS);
    }
  
    private void scheduleFixedRateTask() {
        taskScheduler.scheduleAtFixedRate(() -> {
            log.info("固定频率任务执行: {}", LocalDateTime.now());
            // 注意：如果任务执行时间超过间隔时间，会立即执行下一个任务
        }, 0, 1, TimeUnit.MINUTES);
    }
  
    private void scheduleFixedDelayTask() {
        taskScheduler.scheduleWithFixedDelay(() -> {
            log.info("固定延迟任务执行: {}", LocalDateTime.now());
            try {
                Thread.sleep(10000); // 模拟任务执行时间
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, 0, 2, TimeUnit.MINUTES);
    }
  
    private void scheduleDailyTask() {
        // 计算到下一个凌晨2点的时间
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime nextRun = now.withHour(2).withMinute(0).withSecond(0).withNano(0);
        if (now.compareTo(nextRun) > 0) {
            nextRun = nextRun.plusDays(1);
        }
      
        long initialDelay = Duration.between(now, nextRun).toMillis();
      
        taskScheduler.scheduleAtFixedRate(() -> {
            log.info("每日任务执行: {}", LocalDateTime.now());
            performDailyMaintenance();
        }, initialDelay, TimeUnit.DAYS.toMillis(1), TimeUnit.MILLISECONDS);
    }
  
    private void performDailyMaintenance() {
        log.info("执行每日维护任务");
        // 实现具体的维护逻辑
    }
  
    public ScheduledFuture<?> scheduleCustomTask(Runnable task, long delay, TimeUnit unit) {
        return taskScheduler.schedule(task, delay, unit);
    }
  
    public boolean cancelScheduledTask(ScheduledFuture<?> future) {
        return future.cancel(false);
    }
}

5. WorkStealingPool (工作窃取线程池)

基本使用

@Service
public class WorkStealingPoolService {
  
    // 创建工作窃取线程池，线程数等于CPU核心数
    private final ExecutorService workStealingPool = Executors.newWorkStealingPool();
  
    public void executeParallelTasks(List<Runnable> tasks) {
        List<Future<?>> futures = new ArrayList<>();
      
        for (Runnable task : tasks) {
            futures.add(workStealingPool.submit(task));
        }
      
        // 等待所有任务完成
        for (Future<?> future : futures) {
            try {
                future.get();
            } catch (Exception e) {
                log.error("并行任务执行失败", e);
            }
        }
    }
  
    public <T> List<T> executeParallelCallables(List<Callable<T>> tasks) {
        try {
            // 使用invokeAll同时执行所有任务
            List<Future<T>> futures = workStealingPool.invokeAll(tasks);
          
            List<T> results = new ArrayList<>();
            for (Future<T> future : futures) {
                results.add(future.get());
            }
          
            return results;
        } catch (Exception e) {
            log.error("并行任务执行失败", e);
            return new ArrayList<>();
        }
    }
}

实际应用示例

@Component
public class DataProcessor {
  
    private final ExecutorService dataProcessPool = Executors.newWorkStealingPool();
  
    public List<ProcessedData> processDataParallel(List<RawData> rawDataList) {
        List<Callable<ProcessedData>> tasks = rawDataList.stream()
            .map(this::createProcessTask)
            .collect(Collectors.toList());
      
        try {
            List<Future<ProcessedData>> futures = dataProcessPool.invokeAll(tasks);
          
            List<ProcessedData> results = new ArrayList<>();
            for (Future<ProcessedData> future : futures) {
                try {
                    ProcessedData result = future.get(30, TimeUnit.SECONDS);
                    results.add(result);
                } catch (Exception e) {
                    log.error("数据处理任务执行失败", e);
                }
            }
          
            return results;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return new ArrayList<>();
        }
    }
  
    private Callable<ProcessedData> createProcessTask(RawData rawData) {
        return () -> {
            try {
                // 模拟复杂的数据处理
                Thread.sleep(1000);
              
                ProcessedData processedData = new ProcessedData();
                processedData.setId(rawData.getId());
                processedData.setProcessedValue(rawData.getValue() * 2);
                processedData.setProcessTime(LocalDateTime.now());
              
                return processedData;
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("数据处理被中断", e);
            }
        };
    }
  
    public void processLargeDataset(List<RawData> dataset) {
        // 将大数据集分割成小块
        int chunkSize = 1000;
        List<List<RawData>> chunks = new ArrayList<>();
      
        for (int i = 0; i < dataset.size(); i += chunkSize) {
            int end = Math.min(i + chunkSize, dataset.size());
            chunks.add(dataset.subList(i, end));
        }
      
        // 并行处理每个数据块
        List<Callable<Void>> chunkTasks = chunks.stream()
            .map(this::createChunkProcessTask)
            .collect(Collectors.toList());
      
        try {
            List<Future<Void>> futures = dataProcessPool.invokeAll(chunkTasks);
          
            // 等待所有数据块处理完成
            for (Future<Void> future : futures) {
                future.get();
            }
          
            log.info("大数据集处理完成，共处理 {} 个数据块", chunks.size());
        } catch (Exception e) {
            log.error("大数据集处理失败", e);
        }
    }
  
    private Callable<Void> createChunkProcessTask(List<RawData> chunk) {
        return () -> {
            log.info("开始处理数据块，大小: {}", chunk.size());
          
            for (RawData data : chunk) {
                // 处理单个数据项
                processDataItem(data);
            }
          
            log.info("数据块处理完成，大小: {}", chunk.size());
            return null;
        };
    }
  
    private void processDataItem(RawData data) {
        // 实现具体的数据处理逻辑
        // 这里可以包含复杂的计算、转换等操作
    }
}

6. 自定义线程池

自定义线程工厂

@Component
public class CustomThreadFactory implements ThreadFactory {
  
    private final String namePrefix;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final ThreadGroup group;
  
    public CustomThreadFactory(String namePrefix) {
        this.namePrefix = namePrefix;
        SecurityManager s = System.getSecurityManager();
        this.group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
    }
  
    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
      
        // 设置线程属性
        if (t.isDaemon()) {
            t.setDaemon(false);
        }
        if (t.getPriority() != Thread.NORM_PRIORITY) {
            t.setPriority(Thread.NORM_PRIORITY);
        }
      
        // 设置异常处理器
        t.setUncaughtExceptionHandler((thread, throwable) -> {
            log.error("线程 {} 发生未捕获异常", thread.getName(), throwable);
        });
      
        return t;
    }
}

自定义拒绝策略

@Component
public class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
  
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        if (!executor.isShutdown()) {
            try {
                // 等待一段时间后重试
                if (!executor.getQueue().offer(r, 100, TimeUnit.MILLISECONDS)) {
                    // 如果队列仍然满，则记录日志并丢弃任务
                    log.warn("任务被拒绝，队列已满，丢弃任务: {}", r);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                log.error("任务重试被中断", e);
            }
        }
    }
}

自定义线程池配置

@Configuration
public class CustomThreadPoolConfig {
  
    @Bean("customTaskExecutor")
    public ThreadPoolExecutor customTaskExecutor() {
        return new ThreadPoolExecutor(
            5,                          // 核心线程数
            10,                         // 最大线程数
            60L,                        // 线程空闲时间
            TimeUnit.SECONDS,           // 时间单位
            new LinkedBlockingQueue<>(100), // 工作队列
            new CustomThreadFactory("custom-"), // 自定义线程工厂
            new CustomRejectedExecutionHandler() // 自定义拒绝策略
        );
    }
  
    @Bean("priorityTaskExecutor")
    public ThreadPoolExecutor priorityTaskExecutor() {
        return new ThreadPoolExecutor(
            3,                          // 核心线程数
            6,                          // 最大线程数
            30L,                        // 线程空闲时间
            TimeUnit.SECONDS,           // 时间单位
            new PriorityBlockingQueue<>(50), // 优先级队列
            new CustomThreadFactory("priority-"), // 自定义线程工厂
            new ThreadPoolExecutor.CallerRunsPolicy() // 调用者运行策略
        );
    }
}

应用场景

1. Web服务器并发处理

@Service
public class WebRequestProcessor {
  
    private final ExecutorService threadPool = Executors.newFixedThreadPool(20);
  
    public void processRequest(HttpRequest request) {
        threadPool.submit(() -> {
            try {
                // 处理HTTP请求
                processHttpRequest(request);
            } catch (Exception e) {
                log.error("处理请求失败", e);
            }
        });
    }
  
    private void processHttpRequest(HttpRequest request) {
        // 实现具体的请求处理逻辑
        log.info("处理请求: {}", request.getUrl());
    }
}

2. 文件批量处理

@Service
public class FileBatchProcessor {
  
    private final ExecutorService threadPool = Executors.newFixedThreadPool(10);
  
    public void processFiles(List<File> files) {
        List<Future<String>> futures = new ArrayList<>();
      
        for (File file : files) {
            Future<String> future = threadPool.submit(() -> processFile(file));
            futures.add(future);
        }
      
        // 等待所有任务完成
        for (Future<String> future : futures) {
            try {
                String result = future.get();
                log.info("文件处理完成: {}", result);
            } catch (Exception e) {
                log.error("文件处理失败", e);
            }
        }
    }
  
    private String processFile(File file) {
        // 实现文件处理逻辑
        log.info("处理文件: {}", file.getName());
        return file.getName() + "_processed";
    }
}

3. 数据库批量操作

@Service
public class DatabaseBatchProcessor {
  
    private final ExecutorService threadPool = Executors.newFixedThreadPool(5);
  
    public void batchInsert(List<User> users) {
        int batchSize = 1000;
        List<List<User>> batches = splitIntoBatches(users, batchSize);
      
        List<Future<Void>> futures = new ArrayList<>();
      
        for (List<User> batch : batches) {
            Future<Void> future = threadPool.submit(() -> {
                insertBatch(batch);
                return null;
            });
            futures.add(future);
        }
      
        // 等待所有批次完成
        for (Future<Void> future : futures) {
            try {
                future.get();
            } catch (Exception e) {
                log.error("批量插入失败", e);
            }
        }
    }
  
    private void insertBatch(List<User> users) {
        // 实现批量插入逻辑
        log.info("插入批次，数量: {}", users.size());
    }
  
    private List<List<User>> splitIntoBatches(List<User> users, int batchSize) {
        List<List<User>> batches = new ArrayList<>();
        for (int i = 0; i < users.size(); i += batchSize) {
            batches.add(users.subList(i, Math.min(i + batchSize, users.size())));
        }
        return batches;
    }
}

4. 定时任务执行

@Service
public class ScheduledTaskExecutor {
  
    private final ScheduledExecutorService scheduledExecutor = 
        Executors.newScheduledThreadPool(3);
  
    @PostConstruct
    public void init() {
        // 延迟执行任务
        scheduledExecutor.schedule(() -> {
            log.info("延迟任务执行");
        }, 5, TimeUnit.SECONDS);
      
        // 周期性执行任务
        scheduledExecutor.scheduleAtFixedRate(() -> {
            log.info("周期性任务执行");
        }, 0, 1, TimeUnit.MINUTES);
      
        // 固定延迟执行任务
        scheduledExecutor.scheduleWithFixedDelay(() -> {
            log.info("固定延迟任务执行");
        }, 0, 2, TimeUnit.MINUTES);
    }
}

5. 异步计算任务

@Service
public class AsyncCalculator {
  
    private final ExecutorService threadPool = Executors.newFixedThreadPool(4);
  
    public CompletableFuture<BigDecimal> calculateAsync(BigDecimal number) {
        return CompletableFuture.supplyAsync(() -> {
            // 模拟复杂计算
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return number.multiply(number);
        }, threadPool);
    }
  
    public CompletableFuture<List<BigDecimal>> calculateMultipleAsync(List<BigDecimal> numbers) {
        List<CompletableFuture<BigDecimal>> futures = numbers.stream()
            .map(this::calculateAsync)
            .collect(Collectors.toList());
      
        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
            .thenApply(v -> futures.stream()
                .map(CompletableFuture::join)
                .collect(Collectors.toList()));
    }
}

Spring Boot集成

1. 配置类

@Configuration
@EnableAsync
public class ThreadPoolConfig {
  
    @Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
      
        // 核心线程数
        executor.setCorePoolSize(10);
        // 最大线程数
        executor.setMaxPoolSize(20);
        // 队列容量
        executor.setQueueCapacity(200);
        // 线程空闲时间
        executor.setKeepAliveSeconds(60);
        // 线程名前缀
        executor.setThreadNamePrefix("async-");
        // 拒绝策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 等待所有任务结束后再关闭线程池
        executor.setWaitForTasksToCompleteOnShutdown(true);
        // 等待时间
        executor.setAwaitTerminationSeconds(60);
      
        executor.initialize();
        return executor;
    }
  
    @Bean("ioTaskExecutor")
    public Executor ioTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(20);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(500);
        executor.setThreadNamePrefix("io-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
  
    @Bean("cpuTaskExecutor")
    public Executor cpuTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(Runtime.getRuntime().availableProcessors());
        executor.setMaxPoolSize(Runtime.getRuntime().availableProcessors() * 2);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("cpu-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

2. 异步服务

@Service
public class AsyncUserService {
  
    @Async("taskExecutor")
    public CompletableFuture<User> getUserAsync(Long userId) {
        try {
            Thread.sleep(1000); // 模拟耗时操作
            User user = new User();
            user.setId(userId);
            user.setName("User " + userId);
            return CompletableFuture.completedFuture(user);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return CompletableFuture.failedFuture(e);
        }
    }
  
    @Async("ioTaskExecutor")
    public CompletableFuture<String> processFileAsync(String fileName) {
        try {
            Thread.sleep(2000); // 模拟文件处理
            return CompletableFuture.completedFuture("Processed: " + fileName);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return CompletableFuture.failedFuture(e);
        }
    }
  
    @Async("cpuTaskExecutor")
    public CompletableFuture<BigDecimal> calculateAsync(BigDecimal number) {
        // 模拟CPU密集型计算
        BigDecimal result = BigDecimal.ONE;
        for (int i = 0; i < 1000000; i++) {
            result = result.multiply(number);
        }
        return CompletableFuture.completedFuture(result);
    }
}

3. 控制器

@RestController
@RequestMapping("/api/users")
public class UserController {
  
    @Autowired
    private AsyncUserService asyncUserService;
  
    @GetMapping("/{userId}")
    public CompletableFuture<User> getUser(@PathVariable Long userId) {
        return asyncUserService.getUserAsync(userId);
    }
  
    @PostMapping("/batch-process")
    public CompletableFuture<List<String>> batchProcessFiles(@RequestBody List<String> fileNames) {
        List<CompletableFuture<String>> futures = fileNames.stream()
            .map(asyncUserService::processFileAsync)
            .collect(Collectors.toList());
      
        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
            .thenApply(v -> futures.stream()
                .map(CompletableFuture::join)
                .collect(Collectors.toList()));
    }
  
    @PostMapping("/calculate")
    public CompletableFuture<BigDecimal> calculate(@RequestBody BigDecimal number) {
        return asyncUserService.calculateAsync(number);
    }
}

4. 配置文件

# application.yml
spring:
  task:
    execution:
      pool:
        core-size: 10
        max-size: 20
        queue-capacity: 200
        keep-alive: 60s
      thread-name-prefix: "spring-"

5. 监控和健康检查

@Component
public class ThreadPoolHealthIndicator implements HealthIndicator {
  
    @Autowired
    private ThreadPoolTaskExecutor taskExecutor;
  
    @Override
    public Health health() {
        ThreadPoolExecutor executor = taskExecutor.getThreadPoolExecutor();
      
        int activeCount = executor.getActiveCount();
        int poolSize = executor.getPoolSize();
        int corePoolSize = executor.getCorePoolSize();
        int maximumPoolSize = executor.getMaximumPoolSize();
        long completedTaskCount = executor.getCompletedTaskCount();
        long taskCount = executor.getTaskCount();
      
        Health.Builder builder = Health.up()
            .withDetail("activeCount", activeCount)
            .withDetail("poolSize", poolSize)
            .withDetail("corePoolSize", corePoolSize)
            .withDetail("maximumPoolSize", maximumPoolSize)
            .withDetail("completedTaskCount", completedTaskCount)
            .withDetail("taskCount", taskCount);
      
        // 检查线程池状态
        if (activeCount > maximumPoolSize * 0.8) {
            builder.status(Status.WARNING);
        }
      
        return builder.build();
    }
}

@Component
public class ThreadPoolMonitor {
  
    @Autowired
    private ThreadPoolTaskExecutor taskExecutor;
  
    @Scheduled(fixedRate = 30000) // 每30秒监控一次
    public void monitorThreadPool() {
        ThreadPoolExecutor executor = taskExecutor.getThreadPoolExecutor();
      
        log.info("线程池状态 - 活跃线程: {}, 池大小: {}, 核心线程: {}, 最大线程: {}, 已完成任务: {}, 总任务: {}", 
            executor.getActiveCount(),
            executor.getPoolSize(),
            executor.getCorePoolSize(),
            executor.getMaximumPoolSize(),
            executor.getCompletedTaskCount(),
            executor.getTaskCount());
      
        // 发送监控指标
        sendMetrics(executor);
    }
  
    private void sendMetrics(ThreadPoolExecutor executor) {
        // 这里可以集成Prometheus、Micrometer等监控系统
        // MeterRegistry meterRegistry = ...
        // meterRegistry.gauge("threadpool.active.count", executor.getActiveCount());
        // meterRegistry.gauge("threadpool.pool.size", executor.getPoolSize());
    }
}

最佳实践

1. 线程池参数设置

参数设置建议:
  CPU密集型任务:
    - 核心线程数 = CPU核心数 + 1
    - 最大线程数 = CPU核心数 * 2
    - 队列容量 = 较小值
  
  IO密集型任务:
    - 核心线程数 = CPU核心数 * 2
    - 最大线程数 = CPU核心数 * 4
    - 队列容量 = 较大值
  
  混合型任务:
    - 核心线程数 = CPU核心数 * 1.5
    - 最大线程数 = CPU核心数 * 3
    - 队列容量 = 中等值

2. 拒绝策略选择

// 拒绝策略实现
public class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
  
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        if (!executor.isShutdown()) {
            try {
                // 等待一段时间后重试
                executor.getQueue().offer(r, 100, TimeUnit.MILLISECONDS);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RejectedExecutionException("任务被拒绝", e);
            }
        }
    }
}

3. 线程池关闭

@Component
public class ThreadPoolShutdownHook {
  
    @Autowired
    private ThreadPoolTaskExecutor taskExecutor;
  
    @PreDestroy
    public void shutdown() {
        log.info("开始关闭线程池...");
      
        // 关闭线程池
        taskExecutor.shutdown();
      
        try {
            // 等待所有任务完成
            if (!taskExecutor.awaitTermination(60, TimeUnit.SECONDS)) {
                // 强制关闭
                taskExecutor.shutdownNow();
              
                if (!taskExecutor.awaitTermination(60, TimeUnit.SECONDS)) {
                    log.error("线程池无法关闭");
                }
            }
        } catch (InterruptedException e) {
            taskExecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }
      
        log.info("线程池已关闭");
    }
}

4. 异常处理

@Configuration
public class AsyncExceptionConfig {
  
    @Bean
    public AsyncUncaughtExceptionHandler asyncUncaughtExceptionHandler() {
        return new SimpleAsyncUncaughtExceptionHandler();
    }
}

@Component
public class CustomAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
  
    @Override
    public void handleUncaughtException(Throwable ex, Method method, Object... params) {
        log.error("异步方法执行异常: method={}, params={}", method.getName(), params, ex);
      
        // 发送告警通知
        sendAlertNotification(ex, method, params);
    }
  
    private void sendAlertNotification(Throwable ex, Method method, Object[] params) {
        // 实现告警通知逻辑
        log.warn("发送异常告警: method={}, error={}", method.getName(), ex.getMessage());
    }
}