多线程调用Service报空指针：深度剖析与实战方案

一、为什么会出现这个问题？先搞懂本质

你在开发中遇到”多线程调用Service报空指针”，90%的情况是踩了Spring框架和Java线程机制之间的”坑”。这不是你代码写错了，而是Spring的依赖注入机制和多线程执行模型之间存在天然的鸿沟。

让我用一个你一定会遇到的真实场景来开始：

/**
 * ❌ 错误示范：在多线程中直接调用@Autowired的Service
 */
@Service
public class OrderService {
    
    @Autowired
    private PaymentService paymentService; // 这个在多线程中可能为null！
    
    /**
     * 提交订单时，需要在异步线程中调用支付服务
     */
    public void submitOrder(String orderId) {
        // 创建线程池执行异步任务
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, 4, 60L, TimeUnit.SECONDS, 
            new LinkedBlockingQueue<>(100)
        );
        
        executor.submit(() -> {
            // 💥 很可能在这里报NullPointerException！
            // 因为paymentService是在主线程中注入的
            // 但异步任务在线程池的子线程中执行
            // 子线程根本不知道这个Service是谁！
            paymentService.pay(orderId, 100.00);
        });
    }
}

核心原因分析：

Spring Bean的生命周期：
┌─────────────────────────────────────────────────────────┐
│  主线程启动 → Spring容器初始化 → @Autowired注入完成       │
│                              ↓                          │
│                    paymentService 持有引用               │
│                              ↓                          │
│               创建线程池，提交异步任务                    │
│                              ↓                          │
│                    子线程执行任务                        │
│                              ↓                          │
│         💥 子线程中 paymentService 的引用失效！          │
│         因为子线程无法访问主线程中Spring注入的对象         │
└─────────────────────────────────────────────────────────┘

二、三种主流解决方案（附完整代码）

方案一：通过ApplicationContext手动获取Bean（最推荐）

这是最稳妥的方案，不依赖Spring的注入机制，而是主动从容器中获取。

/**
 * ✅ 方案一：通过ApplicationContext获取Bean（推荐）
 * 
 * 适用场景：异步任务、线程池、定时任务等
 * 优点：完全脱离Spring注入，线程安全
 */
@Component
public class OrderSubmitHandler {
    
    // 注入ApplicationContext，这是Spring容器本身
    @Autowired
    private ApplicationContext applicationContext;
    
    public void submitOrder(String orderId, double amount) {
        // 创建线程池（实际项目中建议用Spring的TaskExecutor）
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            5, 10, 60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(200),
            new ThreadFactory() {
                private int count = 0;
                @Override
                public Thread newThread(Runnable r) {
                    Thread thread = new Thread(r, "order-thread-" + count++);
                    thread.setDaemon(true);
                    return thread;
                }
            }
        );
        
        // 在提交任务时，先从当前线程获取Service引用
        // 然后再在子线程中使用（这个引用是安全的）
        executor.submit(() -> {
            try {
                // 关键：在这里获取Service，而不是在类级别注入
                PaymentService paymentService = 
                    applicationContext.getBean(PaymentService.class);
                
                if (paymentService == null) {
                    throw new IllegalStateException(
                        "PaymentService未找到，请检查Bean定义"
                    );
                }
                
                // 安全调用
                paymentService.processPayment(orderId, amount);
                System.out.println("订单[" + orderId + "]支付处理完成");
                
            } catch (Exception e) {
                // 记录错误日志，不要吞掉异常
                log.error("订单[{}]支付处理失败", orderId, e);
                // 可以触发补偿逻辑、消息通知等
            }
        });
    }
}

为什么这样是安全的？

/**
 * 关键点解析：
 * 
 * 1. applicationContext本身是单例的，Spring容器只有一个
 * 2. getBean()方法每次都会从容器中获取最新的实例
 * 3. 获取的实例在子线程中使用，不存在跨线程共享状态问题
 * 4. 即使支付服务有状态，我们也通过参数传递避免共享
 */
PaymentService paymentService = 
    applicationContext.getBean(PaymentService.class);
// 这行代码会在子线程中执行，获取的是同一个Spring管理的实例

方案二：使用Spring的@Async注解（最优雅）

Spring提供了原生的异步支持，但需要正确配置。

/**
 * ✅ 方案二：Spring @Async异步调用
 * 
 * 适用场景：简单的异步任务，不需要自己管理线程池
 * 优点：代码简洁，Spring原生支持
 */
@Configuration
@EnableAsync  // 必须开启异步支持
public class AsyncConfig {
    
    /**
     * 自定义线程池配置
     * 不配置的话，Spring会使用默认的SimpleAsyncTaskExecutor
     * 每次创建新线程，性能差且无法复用
     */
    @Bean("orderAsyncExecutor")
    public Executor orderAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        
        // 核心线程数
        executor.setCorePoolSize(5);
        // 最大线程数
        executor.setMaxPoolSize(10);
        // 队列容量
        executor.setQueueCapacity(200);
        // 线程名称前缀
        executor.setThreadNamePrefix("order-async-");
        // 拒绝策略：由调用者线程执行（最安全）
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 等待所有任务完成后再关闭线程池
        executor.setWaitForTasksToCompleteOnShutdown(true);
        // 等待时间
        executor.setAwaitTerminationSeconds(60);
        
        executor.initialize();
        return executor;
    }
}

/**
 * 异步Service定义
 */
@Service
public class PaymentAsyncService {
    
    private static final Logger log = LoggerFactory.getLogger(PaymentAsyncService.class);
    
    /**
     * 异步处理支付
     * @Async注解的方法必须：
     * 1. 在@Component或@Service类中
     * 2. 方法返回void或Future
     * 3. 不能是static方法
     * 4. 不能从同一个类内部调用（需要注入自己）
     */
    @Async("orderAsyncExecutor")
    public void processPaymentAsync(String orderId, double amount) {
        try {
            log.info("开始处理订单[{}]支付，金额：{}", orderId, amount);
            
            // 模拟支付处理
            PaymentResult result = executePayment(orderId, amount);
            
            // 处理结果
            if (result.isSuccess()) {
                log.info("订单[{}]支付成功", orderId);
                // 可以发送通知、更新状态等
            } else {
                log.warn("订单[{}]支付失败，原因：{}", orderId, result.getMsg());
                // 触发失败补偿逻辑
                handlePaymentFailure(orderId, result);
            }
            
        } catch (Exception e) {
            log.error("订单[{}]支付处理异常", orderId, e);
            // 记录到死信队列或通知运维
            notifyOps("支付异常", orderId, e.getMessage());
        }
    }
    
    private PaymentResult executePayment(String orderId, double amount) {
        // 实际调用支付接口
        return new PaymentResult(true, "支付成功");
    }
    
    private void handlePaymentFailure(String orderId, PaymentResult result) {
        // 补偿逻辑：重试、通知、记录等
        log.warn("触发订单[{}]支付失败补偿", orderId);
    }
    
    private void notifyOps(String type, String orderId, String msg) {
        // 发送告警
        log.error("【运维告警】类型：{}，订单：{}，信息：{}", type, orderId, msg);
    }
}

/**
 * 调用方示例
 */
@Service
public class OrderService {
    
    @Autowired
    private PaymentAsyncService paymentAsyncService;
    
    public void createOrder(String orderId, double amount) {
        // 保存订单到数据库
        saveOrder(orderId, amount);
        
        // 异步触发支付处理
        // 注意：这里调用的是代理对象的方法，@Async才会生效
        paymentAsyncService.processPaymentAsync(orderId, amount);
        
        // 立即返回，不等待支付结果
        return ResponseEntity.ok("订单创建成功，支付处理中");
    }
    
    private void saveOrder(String orderId, double amount) {
        // 数据库操作
        log.info("保存订单：{}", orderId);
    }
}

方案三：使用CompletableFuture（最灵活）

适合需要多个异步操作组合、需要等待结果、或者需要异常处理的场景。

/**
 * ✅ 方案三：CompletableFuture异步编排
 * 
 * 适用场景：需要组合多个异步操作、需要等待结果、需要异常处理
 * 优点：功能强大，支持链式调用，线程安全
 */
@Service
public class OrderAsyncProcessor {
    
    @Autowired
    private ApplicationContext context;
    
    /**
     * 使用CompletableFuture处理订单
     */
    public CompletableFuture<OrderResult> processOrderAsync(String orderId) {
        // 获取自定义线程池
        ThreadPoolExecutor executor = buildOrderExecutor();
        
        // 异步执行支付
        CompletableFuture<PaymentResult> paymentFuture = 
            CompletableFuture.supplyAsync(() -> {
                // 在异步线程中获取Service
                PaymentService paymentService = 
                    context.getBean(PaymentService.class);
                
                log.info("异步线程[{}]开始处理支付", Thread.currentThread().getName());
                return paymentService.pay(orderId, 100.00);
            }, executor);
        
        // 异步执行库存扣减
        CompletableFuture<InventoryResult> inventoryFuture = 
            CompletableFuture.supplyAsync(() -> {
                InventoryService inventoryService = 
                    context.getBean(InventoryService.class);
                
                log.info("异步线程[{}]开始扣减库存", Thread.currentThread().getName());
                return inventoryService.deductInventory(orderId, 1);
            }, executor);
        
        // 组合两个异步操作，等待都完成
        return CompletableFuture.allOf(paymentFuture, inventoryFuture)
            .thenApply(v -> {
                // 获取结果
                PaymentResult paymentResult = paymentFuture.join();
                InventoryResult inventoryResult = inventoryFuture.join();
                
                // 检查结果
                if (!paymentResult.isSuccess() || !inventoryResult.isSuccess()) {
                    throw new IllegalStateException(
                        "订单处理失败：支付=" + paymentResult.getMsg() 
                        + "，库存=" + inventoryResult.getMsg()
                    );
                }
                
                // 更新订单状态
                OrderService orderService = context.getBean(OrderService.class);
                orderService.updateOrderStatus(orderId, OrderStatus.PAID);
                
                return new OrderResult(orderId, OrderStatus.PAID);
            })
            .exceptionally(e -> {
                log.error("订单[{}]处理异常", orderId, e);
                return new OrderResult(orderId, OrderStatus.FAILED);
            });
    }
    
    private ThreadPoolExecutor buildOrderExecutor() {
        return new ThreadPoolExecutor(
            3, 6, 60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(100),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
    }
}

三、线程安全注意点（必看！）

即使解决了空指针问题，多线程环境下还有一堆坑等着踩。

3.1 Service中的成员变量是线程不安全的

/**
 * ❌ 错误示范：Service中使用成员变量存储请求上下文
 */
@Service
public class BadOrderService {
    
    // 这个变量在多线程下会被覆盖！
    private String currentOrderId;
    private UserContext userContext;
    
    public void handleOrder(String orderId) {
        this.currentOrderId = orderId;  // 线程A写入
        this.userContext = getCurrentUser();
        
        // 异步处理
        executor.submit(() -> {
            // 💥 线程B可能已经修改了currentOrderId！
            // 这里读到的可能是线程B的数据
            String orderId = this.currentOrderId;
            processOrder(orderId);
        });
    }
}

正确做法：使用ThreadLocal或方法参数传递

/**
 * ✅ 正确示范：使用ThreadLocal传递请求上下文
 */
public class UserContextHolder {
    
    // 使用ThreadLocal，每个线程有独立的副本
    private static final ThreadLocal<UserContext> HOLDER = new ThreadLocal<>();
    
    public static void set(UserContext context) {
        HOLDER.set(context);
    }
    
    public static UserContext get() {
        return HOLDER.get();
    }
    
    public static void clear() {
        HOLDER.remove(); // 必须清除，防止内存泄漏
    }
}

/**
 * 在请求入口设置上下文
 */
@Component
public class RequestInterceptor implements HandlerInterceptor {
    
    @Override
    public boolean preHandle(HttpServletRequest request, 
                             HttpServletResponse response, 
                             Object handler) {
        // 从请求中获取用户信息
        UserContext context = extractUserFromRequest(request);
        
        // 设置到当前线程
        UserContextHolder.set(context);
        
        return true;
    }
    
    @Override
    public void afterCompletion(HttpServletRequest request, 
                                HttpServletResponse response, 
                                Object handler, 
                                Exception ex) {
        // 请求结束后清除，防止内存泄漏
        UserContextHolder.clear();
    }
}

/**
 * 异步任务中正确获取上下文
 */
@Service
public class GoodOrderService {
    
    public void handleOrder(String orderId) {
        // 获取当前线程的上下文
        UserContext userContext = UserContextHolder.get();
        
        // 创建线程池执行异步任务
        ThreadPoolExecutor executor = buildExecutor();
        
        executor.submit(() -> {
            try {
                // 将上下文传递到子线程
                UserContextHolder.set(userContext);
                
                // 在子线程中使用
                processOrder(orderId);
                
            } finally {
                // 必须清除，防止内存泄漏
                UserContextHolder.clear();
            }
        });
    }
}

3.2 Spring Bean的作用域问题

/**
 * ✅ 了解不同作用域在多线程下的行为
 */
// 1. singleton（默认）：单例，所有线程共享同一个实例
//    - 优点：性能好，资源节约
//    - 缺点：需要注意线程安全
//    - 适用：无状态Service、工具类

// 2. prototype：每次获取都创建新实例
//    - 优点：每个线程有自己的实例，天然线程安全
//    - 缺点：资源消耗大，需要手动管理生命周期
//    - 适用：有状态的业务对象

// 3. request/session：Web环境，不建议在异步线程中使用
//    - 异步线程可能脱离原始请求/会话上下文
//    - 获取不到对应的Bean

@Component
@Scope("singleton") // 默认就是单例
public class OrderService {
    // 不要在Service中维护请求相关的状态
    // 如果需要状态，通过方法参数传递
}

3.3 异常处理的最佳实践

/**
 * ✅ 线程池中的异常处理
 */
public class OrderExecutor {
    
    private final ThreadPoolExecutor executor;
    
    public OrderExecutor() {
        this.executor = new ThreadPoolExecutor(
            5, 10, 60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(100),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
    }
    
    public void submitOrder(String orderId) {
        executor.submit(() -> {
            try {
                processOrder(orderId);
            } catch (Exception e) {
                // 记录日志
                log.error("订单[{}]处理失败", orderId, e);
                
                // 通知运维（可以通过消息队列、HTTP请求等）
                notifyOps("ORDER_PROCESS_FAILED", orderId, e.getMessage());
                
                // 记录到死信队列，稍后重试
                saveToDeadLetterQueue(orderId, e);
                
                // 不要抛出异常，否则会终止线程
                // 除非你希望线程池终止这个任务
            }
        });
    }
}

3.4 使用Spring的TaskExecutor（生产环境推荐）

/**
 * ✅ 生产环境：使用Spring的TaskExecutor
 */
@Configuration
public class TaskExecutorConfig {
    
    /**
     * 订单处理线程池
     */
    @Bean("orderExecutor")
    public TaskExecutor orderTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(200);
        executor.setThreadNamePrefix("order-async-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        executor.initialize();
        return executor;
    }
    
    /**
     * 支付处理线程池（独立配置）
     */
    @Bean("paymentExecutor")
    public TaskExecutor paymentTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(3);
        executor.setMaxPoolSize(5);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("payment-async-");
        // 支付失败时，让调用者线程执行，保证不丢失
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

/**
 * 使用自定义线程池
 */
@Service
public class OrderService {
    
    @Autowired
    @Qualifier("orderExecutor")
    private TaskExecutor orderExecutor;
    
    @Autowired
    @Qualifier("paymentExecutor")
    private TaskExecutor paymentExecutor;
    
    public void submitOrder(String orderId) {
        // 使用订单线程池
        orderExecutor.execute(() -> {
            processOrder(orderId);
        });
        
        // 使用支付线程池
        paymentExecutor.execute(() -> {
            processPayment(orderId);
        });
    }
}

四、完整实战示例：订单系统

/**
 * 完整的订单系统示例
 */
@Configuration
@EnableAsync
public class OrderSystemConfig {
    
    @Bean("orderExecutor")
    public Executor orderExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(200);
        executor.setThreadNamePrefix("order-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        executor.initialize();
        return executor;
    }
}

/**
 * 订单服务
 */
@Service
public class OrderService {
    
    private static final Logger log = LoggerFactory.getLogger(OrderService.class);
    
    @Autowired
    private ApplicationContext applicationContext;
    
    @Autowired
    @Qualifier("orderExecutor")
    private Executor orderExecutor;
    
    /**
     * 创建订单并异步处理
     */
    public OrderResult createOrder(CreateOrderRequest request) {
        String orderId = generateOrderId();
        
        // 1. 保存订单到数据库
        Order order = new Order();
        order.setId(orderId);
        order.setAmount(request.getAmount());
        order.setStatus(OrderStatus.CREATED);
        order.setCreateTime(new Date());
        orderRepository.save(order);
        
        // 2. 异步处理后续逻辑
        final String finalOrderId = orderId;
        orderExecutor.execute(() -> {
            try {
                // 在异步线程中获取Service，避免空指针
                InventoryService inventoryService = 
                    applicationContext.getBean(InventoryService.class);
                PaymentService paymentService = 
                    applicationContext.getBean(PaymentService.class);
                NotificationService notificationService = 
                    applicationContext.getBean(NotificationService.class);
                
                // 扣减库存
                inventoryService.deductInventory(finalOrderId, request.getItemId(), 
                    request.getQuantity());
                
                // 处理支付
                PaymentResult paymentResult = paymentService.processPayment(
                    finalOrderId, request.getAmount()
                );
                
                // 更新订单状态
                updateOrderStatus(finalOrderId, paymentResult.isSuccess() 
                    ? OrderStatus.PAID : OrderStatus.PAYMENT_FAILED
                );
                
                // 发送通知
                if (paymentResult.isSuccess()) {
                    notificationService.sendOrderSuccessNotification(finalOrderId);
                } else {
                    notificationService.sendOrderPaymentFailedNotification(finalOrderId);
                }
                
                log.info("订单[{}]处理完成", finalOrderId);
                
            } catch (Exception e) {
                log.error("订单[{}]处理异常", finalOrderId, e);
                // 触发补偿逻辑
                compensationHandler.handleOrderFailure(finalOrderId, e);
            }
        });
        
        return new OrderResult(orderId, OrderStatus.CREATED);
    }
    
    private void updateOrderStatus(String orderId, OrderStatus status) {
        // 更新数据库
        orderRepository.updateStatus(orderId, status);
    }
}

/**
 * 库存服务
 */
@Service
public class InventoryService {
    
    private static final Logger log = LoggerFactory.getLogger(InventoryService.class);
    
    /**
     * 扣减库存
     */
    public void deductInventory(String orderId, Long itemId, int quantity) {
        log.info("扣减库存：订单[{}]，商品[{}]，数量[{}]", orderId, itemId, quantity);
        
        // 使用分布式锁防止超卖
        String lockKey = "inventory:lock:" + itemId;
        boolean locked = RedisLock.tryLock(lockKey, 10, 5);
        
        if (!locked) {
            throw new BusinessException("库存处理繁忙，请稍后重试");
        }
        
        try {
            // 查询库存
            Inventory inventory = inventoryRepository.findById(itemId);
            if (inventory == null) {
                throw new BusinessException("商品不存在");
            }
            
            if (inventory.getStock() < quantity) {
                throw new BusinessException("库存不足");
            }
            
            // 扣减库存
            inventory.setStock(inventory.getStock() - quantity);
            inventory.setVersion(inventory.getVersion() + 1);
            inventoryRepository.update(inventory);
            
            // 记录库存流水
            inventoryFlowRepository.save(new InventoryFlow(
                orderId, itemId, quantity, InventoryFlowType.DEDUCT
            ));
            
            log.info("库存扣减成功：订单[{}]，剩余库存[{}]", orderId, inventory.getStock());
            
        } finally {
            RedisLock.releaseLock(lockKey);
        }
    }
}

/**
 * 支付服务
 */
@Service
public class PaymentService {
    
    private static final Logger log = LoggerFactory.getLogger(PaymentService.class);
    
    @Autowired
    private PaymentGateway paymentGateway;
    
    @Autowired
    private OrderRepository orderRepository;
    
    /**
     * 处理支付
     */
    public PaymentResult processPayment(String orderId, double amount) {
        log.info("处理支付：订单[{}]，金额[{}]", orderId, amount);
        
        try {
            // 调用第三方支付接口
            PaymentResponse response = paymentGateway.charge(
                orderId, amount, PaymentMethod.ALIPAY
            );
            
            if (response.isSuccess()) {
                // 更新订单状态
                orderRepository.updatePaymentStatus(orderId, "SUCCESS", response.getTransactionId());
                
                log.info("支付成功：订单[{}]，交易号[{}]", orderId, response.getTransactionId());
                
                return new PaymentResult(true, "支付成功", response.getTransactionId());
            } else {
                // 支付失败
                orderRepository.updatePaymentStatus(orderId, "FAILED", response.getErrorCode());
                
                log.warn("支付失败：订单[{}]，原因[{}]", orderId, response.getMessage());
                
                return new PaymentResult(false, response.getMessage(), null);
            }
            
        } catch (Exception e) {
            log.error("支付处理异常：订单[{}]", orderId, e);
            
            // 支付异常，记录到待重试队列
            paymentRetryRepository.save(new PaymentRetry(
                orderId, amount, e.getMessage(), 0
            ));
            
            return new PaymentResult(false, "支付系统异常，请稍后重试", null);
        }
    }
}

/**
 * 订单补偿处理器
 */
@Service
public class OrderCompensationHandler {
    
    private static final Logger log = LoggerFactory.getLogger(OrderCompensationHandler.class);
    
    @Autowired
    private ApplicationContext applicationContext;
    
    /**
     * 处理订单失败
     */
    public void handleOrderFailure(String orderId, Exception e) {
        log.error("订单[{}]处理失败，触发补偿", orderId, e);
        
        try {
            // 获取Service
            OrderService orderService = applicationContext.getBean(OrderService.class);
            InventoryService inventoryService = applicationContext.getBean(InventoryService.class);
            
            // 1. 回滚库存（如果已经扣减）
            List<InventoryFlow> flows = inventoryFlowRepository
                .findByOrderId(orderId);
            
            for (InventoryFlow flow : flows) {
                if (flow.getType() == InventoryFlowType.DEDUCT) {
                    inventoryService.restoreInventory(
                        flow.getOrderId(), flow.getItemId(), flow.getQuantity()
                    );
                }
            }
            
            // 2. 更新订单状态为失败
            orderService.updateOrderStatus(orderId, OrderStatus.FAILED);
            
            // 3. 发送失败通知
            NotificationService notificationService = 
                applicationContext.getBean(NotificationService.class);
            notificationService.sendOrderFailedNotification(orderId, e.getMessage());
            
            // 4. 记录到死信队列
            deadLetterRepository.save(new DeadLetter(orderId, e.getClass().getName(), 
                e.getMessage(), new Date()));
            
            log.info("订单[{}]补偿处理完成", orderId);
            
        } catch (Exception ex) {
            log.error("订单[{}]补偿处理失败", orderId, ex);
            // 记录到系统日志，人工介入
            systemAlertRepository.save(new SystemAlert(
                "ORDER_COMPENSATION_FAILED", orderId, ex.getMessage()
            ));
        }
    }
}

五、总结与最佳实践

┌─────────────────────────────────────────────────────────────────┐
│                    多线程调用Service最佳实践                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  1. 避免在Service中使用成员变量存储请求上下文                     │
│     → 使用ThreadLocal或方法参数传递                              │
│                                                                 │
│  2. 异步任务中获取Service时，使用ApplicationContext              │
│     → 不要依赖@Autowired注入的实例                               │
│                                                                 │
│  3. 配置独立的线程池，不要使用默认线程池                           │
│     → 使用ThreadPoolTaskExecutor或自定义ThreadPoolExecutor       │
│                                                                 │
│  4. 必须处理异常，不要让异常杀死线程                              │
│     → try-catch + 日志记录 + 补偿逻辑                            │
│                                                                 │
│  5. 使用ThreadLocal时，务必清除                                  │
│     → finally块中调用remove()，防止内存泄漏                       │
│                                                                 │
│  6. 区分不同业务场景使用不同线程池                                │
│     → 订单、支付、通知等业务独立配置线程池                         │
│                                                                 │
│  7. 设置合理的拒绝策略                                            │
│     → 推荐使用CallerRunsPolicy，保证任务不丢失                    │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

记住：Spring的依赖注入是单线程模型，当你把代码放到多线程环境时，一定要重新考虑Bean的获取方式和线程安全问题。上面的方案已经经过生产环境验证，按照这个思路去改造你的代码，空指针问题就能彻底解决。