Java线程生命周期管理：从手动创建到高效线程池的最佳实践

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import org.springframework.stereotype.Service;

@Service
public class AdvertService {

    // 配置一个固定大小的线程池，例如核心线程数2，最大线程数5
    // 队列容量100，拒绝策略为CallerRunsPolicy
    private final ExecutorService executorService = new ThreadPoolExecutor(
            2, // corePoolSize: 核心线程数
            5, // maximumPoolSize: 最大线程数
            60L, TimeUnit.SECONDS, // keepAliveTime: 空闲线程存活时间
            new LinkedBlockingQueue<>(100), // workQueue: 任务队列
            new ThreadPoolExecutor.CallerRunsPolicy() // handler: 拒绝策略
    );

    // 假设 advertRepository 和 populateAdvertSearch 方法已定义
    // private final AdvertRepository advertRepository;
    // private void populateAdvertSearch(Advert advert) throws ParseException, OfficeNotFoundException, OfficePropertyNotFoundException { /* ... */ }

    public Advert saveAdvert(Advert advert) {
        // 保存广告主对象
        Advert advertToSave = advertRepository.save(advert);

        // 将 populateAdvertSearch 任务提交到线程池执行
        executorService.submit(() -> {
            try {
                populateAdvertSearch(advertToSave);
            } catch (ParseException | OfficeNotFoundException | OfficePropertyNotFoundException e) {
                // 异步任务中的异常处理，记录日志或进行补偿
                System.err.println("Error populating advert search: " + e.getMessage());
                e.printStackTrace();
            }
        });
        return advertToSave;
    }

    // 在应用关闭时，需要优雅地关闭线程池
    public void shutdown() {
        executorService.shutdown();
        try {
            // 等待所有任务完成，最多等待60秒
            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
                executorService.shutdownNow(); // 强制关闭
            }
        } catch (InterruptedException e) {
            executorService.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync // 启用异步方法支持
public class YourApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AdvertService {

    // 假设 advertRepository 已注入
    // private final AdvertRepository advertRepository;

    public Advert saveAdvert(Advert advert) {
        Advert advertToSave = advertRepository.save(advert);
        // 调用异步方法
        populateAdvertSearchAsync(advertToSave);
        return advertToSave;
    }

    @Async // 此方法将在独立的线程中异步执行
    public void populateAdvertSearchAsync(Advert advert) {
        try {
            // populateAdvertSearch 是耗时操作
            populateAdvertSearch(advert);
        } catch (ParseException | OfficeNotFoundException | OfficePropertyNotFoundException e) {
            // 异步任务中的异常处理，记录日志
            System.err.println("Error populating advert search asynchronously: " + e.getMessage());
            e.printStackTrace();
        }
    }

    // 假设这是一个私有方法，执行实际的耗时操作
    private void populateAdvertSearch(Advert advert) throws ParseException, OfficeNotFoundException, OfficePropertyNotFoundException {
        // 模拟耗时操作
        try {
            Thread.sleep(2000);
            System.out.println("Advert search populated for: " + advert.getId() + " by thread: " + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println("populateAdvertSearch interrupted.");
        }
    }
}

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 AsyncConfig {

    @Bean(name = "taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2); // 核心线程数
        executor.setMaxPoolSize(5);  // 最大线程数
        executor.setQueueCapacity(100); // 队列容量
        executor.setThreadNamePrefix("AdvertAsyncTask-"); // 线程名前缀
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 拒绝策略
        executor.initialize();
        return executor;
    }
}