SpringBoot集成自定义线程池和异常处理的两种方式

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.ThreadPoolExecutor;

@Configuration
public class AsyncConfig {

    @Bean("bizTaskExecutor")
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("biz-async-");
        // 拒绝策略：由调用线程执行，起到背压作用
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;

@Service
public class OrderService {

    @Async("bizTaskExecutor")
    public CompletableFuture<String> queryUserAsync() {
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
        return CompletableFuture.completedFuture("User_1001");
    }

    @Async("bizTaskExecutor")
    public CompletableFuture<String> queryOrderAsync() {
        try { Thread.sleep(1200); } catch (InterruptedException e) {}
        return CompletableFuture.completedFuture("Order_List");
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.CompletableFuture;

@RestController
public class OrderController {

    @Autowired
    private OrderService orderService;

    @GetMapping("/order/detail")
    public String getOrderDetail() throws Exception {
        // 并行发起两个异步请求
        CompletableFuture<String> userFuture = orderService.queryUserAsync();
        CompletableFuture<String> orderFuture = orderService.queryOrderAsync();

        // 等待所有任务完成并合并结果
        CompletableFuture.allOf(userFuture, orderFuture).join();
        
        return "用户: " + userFuture.get() + ", 订单: " + orderFuture.get();
    }
}

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import lombok.extern.slf4j.Slf4j;
import java.lang.reflect.Method;

@Slf4j
public class CustomAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {

    @Override
    public void handleUncaughtException(Throwable ex, Method method, Object... params) {
        log.error("异步任务异常 - 方法: {}, 参数: {}", method.getName(), params, ex);
        // 此处可集成监控告警（如 Sentry/Prometheus）
    }
}

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;

@Configuration
public class AsyncConfig implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("biz-async-");
        executor.initialize();
        return executor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new CustomAsyncExceptionHandler();
    }
}

future.thenApply(res -> process(res))
      .exceptionally(ex -> {
          log.error("业务处理失败", ex);
          return defaultResult; // 返回默认值，防止链路中断
      });