Spring Boot 新线程与 @Async 里事务不传播

事务是绑定在线程上的，不是绑定在方法调用链上的。TransactionSynchronizationManager 用 ThreadLocal 存事务上下文，new Thread / @Async 里的代码天然拿不到外层事务——子线程里的写操作会各自开一个独立事务，外层回滚时它们纹丝不动。

Issue & Env（案发现场与环境）

技术栈：Spring Boot 2.x / 3.x、Spring Framework 声明式事务（@Transactional）、多线程并发（new Thread / @Async / 自定义线程池）
业务场景：在主订单事务方法中，为了优化性能或解耦，将某些写入操作（如站内信、操作审计记录、消息表持久化）丢入子线程或异步任务中执行，以为它们共处于同一个事务中。
故障特征：当主业务后续步骤发生未捕获异常导致主事务全部回滚时，子线程所执行的数据库写操作依然停留在数据库中，未发生回滚，造成严重的数据不一致和脏数据残留。

StackTrace（堆栈日志）

该场景下代码不报框架异常，但开启 DataSourceTransactionManager 的 DEBUG 日志后，可捕获到关键的事务绑定痕迹：

logging.level.org.springframework.jdbc.datasource.DataSourceTransactionManager=DEBUG

控制台日志截取：

// 1. 主线程开启外层事务
2026-09-14 10:15:30 DEBUG o.s.j.d.DataSourceTransactionManager : Creating new transaction with name [com.example.OrderService.createOrder]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT

// 2. 子线程执行写操作：并非加入现有事务，而是创建了全新的独立事务
2026-09-14 10:15:30 DEBUG o.s.j.d.DataSourceTransactionManager : Creating new transaction with name [null]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT
// 注意：如果是同一个事务，此处日志应当是 "Participating in existing transaction"

// 3. 子线程先提交
2026-09-14 10:15:31 DEBUG o.s.j.d.DataSourceTransactionManager : Initiating transaction commit

// 4. 主线程异常触发回滚
2026-09-14 10:15:32 DEBUG o.s.j.d.DataSourceTransactionManager : Initiating transaction rollback

日志确凿证据：子线程记录为 Creating new transaction 而不是 Participating in existing transaction，证实两者的数据库连接完全独立。

Reproduce（复现代码）

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private MessageMapper messageMapper;

    @Autowired
    private InventoryService inventoryService;

    @Transactional
    public void createOrder(Order order) {
        // 1. 主线程插入订单
        orderMapper.insert(order);

        // 2. 错误做法：以为子线程能共享外层事务
        new Thread(() -> {
            messageMapper.insert(buildMessage(order));
        }).start();

        // 3. 模拟扣减库存并发生异常
        inventoryService.deduct(order.getSkuId(), order.getCount());
        throw new RuntimeException("测试主事务异常回滚");
    }

    private Message buildMessage(Order order) {
        return new Message(order.getId(), "订单创建成功");
    }
}

执行结果：

主表 order 插入回滚。
子线程执行的 message 插入成功提交并永久留存在数据库中。

Root Cause（根因分析）

Spring 声明式事务的底层资源绑定机制如下：

TransactionInterceptor 开启事务
  → DataSourceUtils.getConnection() 从 TransactionSynchronizationManager 获取绑定资源
  → 事务上下文（Connection、rollback-only 标记等）全部保存在 ThreadLocal 中
  → 同一线程内的所有数据库操作共享同一数据库连接，保证 ACID

ThreadLocal 是“每个线程独有一份副本”的存储模型：

子线程无法直接继承或访问父线程的 ThreadLocal 变量。
数据库事务本质上对应一个物理数据库连接（Connection），JDBC 规范不支持多个线程同时并发交织使用同一个连接执行事务操作。
Spring 官方从未提供跨线程传递活跃数据库事务的机制。子线程调用任何 DAO 操作时，由于检测不到当前线程的事务绑定，会独立申请连接并单独管理事务生命周期。

代码静态审查手段：使用 grep 排查业务 Service 事务方法中是否存在直接开启子线程或异步任务的危险模式：

grep -rn -B2 "new Thread\|CompletableFuture.runAsync\|taskExecutor.execute\|@Async" src/main/java --include="*Service*"

The Fix（解决方案）

方案 A（推荐）：将事务性写操作保留在主线程

如果数据必须与主事务保持强一致性原子提交与回滚，必须保留在主线程执行；子线程只负责纯非事务的只读、计算、RPC、推送等操作：

@Transactional
public void createOrder(Order order) {
    // 事务写入留在主线程
    orderMapper.insert(order);
    messageMapper.insert(buildMessage(order));
    inventoryService.deduct(order.getSkuId(), order.getCount());

    // 真正的异步任务仅执行非事务通知或旁路计算
    notifyExecutor.execute(() -> pushNotification(order));
}

方案 B：子线程使用 TransactionTemplate 管理独立事务

如果业务明确允许子任务独立提交（例如落审计日志或埋点），使用 TransactionTemplate 显式包裹子线程操作，并做好失败兜底补偿：

@Autowired
private TransactionTemplate transactionTemplate;

public void createOrder(Order order) {
    orderMapper.insert(order);

    asyncExecutor.execute(() -> {
        transactionTemplate.executeWithoutResult(status -> {
            messageMapper.insert(buildMessage(order));
        });
    });
}

注意：此方案下两者解耦，外层回滚绝不会联动子线程回滚。

方案 C：基于事务同步回调（TransactionSynchronizationManager）

若异步任务依赖主事务必须成功提交后才触发，使用事务提交回调：

@Transactional
public void createOrder(Order order) {
    orderMapper.insert(order);
    inventoryService.deduct(order.getSkuId(), order.getCount());

    TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
        @Override
        public void afterCommit() {
            // 只有主事务确认 commit 成功后，才触发异步线程
            asyncExecutor.execute(() -> messageService.sendNotice(order));
        }
    });
}

总结与避坑要点

事务绑定线程而非方法调用链路，ThreadLocal 的物理边界决定了跨线程绝不可能隐式继承事务。
切勿尝试用 InheritableThreadLocal 或共享 Connection 来实现跨线程事务，这会引发致命的连接并发死锁与协议错乱。
牢记原则：业务强一致性语义优先于所谓的并发性能优化。

References（参考来源）

Spring Framework Docs: Transaction synchronization and Threadsdocs