如何防止@Transactional在方法内启新线程时提前关闭事务？

首先得把问题根源说清楚：Spring的事务管理是绑定到当前线程上下文的。当你在标注@Transactional的方法里启动新线程后，原方法执行到return null就结束了——这时候Spring会自动触发事务的提交/回滚，并且回收对应的数据库连接。但你把原线程事务的Connection传给了新线程，新线程还在处理业务呢，连接已经被回收，自然就抛出connnection proxy not usable after transaction completion的错误。

下面给你几个适配不同业务场景的解决方案：

方案1：让原线程等待子线程执行完成（同步化异步任务） #

如果你的业务允许原方法阻塞直到子线程处理完毕，最直接的办法就是在提交任务后调用Future.get()，让原线程等待子线程完成，这样事务就不会提前关闭。修改后的代码如下：

@Transactional 
public Void process(Data data) throws InterruptedException, ExecutionException {
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    Connection connection = HibernateUtil.getConnection(sessionFactory.getCurrentSession());
    Future<?> future = executorService.submit(new ProcessJob(connection));
    
    // 等待子线程执行完成，确保事务在子线程结束后再关闭
    future.get();
    
    // 手动关闭线程池，避免线程资源泄漏
    executorService.shutdown();
    return null;
}

⚠️ 注意：这种方式相当于把异步任务变成了同步执行，会增加原方法的响应时间，如果子线程执行耗时较长，可能会影响接口性能，需要结合业务场景评估是否可行。

方案2：让子线程使用独立事务（推荐） #

如果你的业务需要真正的异步处理，而且子线程的数据库操作不需要和原事务绑定，那最好的做法是让子线程自己开启独立的事务，不要传递原线程的Connection。

你可以把ProcessJob改成Spring管理的Bean，在它的执行方法上标注@Transactional，这样Spring会自动为新线程分配独立的事务和数据库连接：

@Component
public class ProcessJob implements Runnable {

    @Autowired
    private SessionFactory sessionFactory;

    @Override
    @Transactional // 子线程的独立事务
    public void run() {
        // 直接使用Session，不需要外部传Connection
        Session session = sessionFactory.getCurrentSession();
        // 执行你的数据库操作逻辑...
    }
}

然后原方法里直接注入这个Bean并提交任务：

@Autowired
private ProcessJob processJob;

@Transactional 
public Void process(Data data) {
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    executorService.submit(processJob);
    
    executorService.shutdown();
    return null;
}

这种方式的好处是两个事务完全独立，原方法可以正常结束并提交自己的事务，子线程的事务由Spring单独管理，不会互相干扰。如果需要保证原事务和子线程事务的一致性，可能需要引入分布式事务（比如XA）或者消息队列的最终一致性方案。

方案3：使用Spring的@Async注解简化异步任务 #

如果你不想自己管理线程池，Spring的@Async注解可以帮你更规范地实现异步任务，同时配合@Transactional也能轻松实现子线程的独立事务：

首先在Spring配置类上开启异步支持：

@Configuration
@EnableAsync
public class AsyncConfig {
    // 自定义线程池配置，控制线程资源
    @Bean(name = "taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(20);
        executor.setThreadNamePrefix("ProcessJob-");
        executor.initialize();
        return executor;
    }
}

然后定义异步服务类：

@Service
public class AsyncProcessService {

    @Autowired
    private SessionFactory sessionFactory;

    @Async("taskExecutor") // 指定使用自定义线程池
    @Transactional
    public void asyncProcess() {
        Session session = sessionFactory.getCurrentSession();
        // 执行你的异步业务逻辑...
    }
}

最后在原方法里调用：

@Autowired
private AsyncProcessService asyncProcessService;

@Transactional 
public Void process(Data data) {
    asyncProcessService.asyncProcess();
    return null;
}

这种方式更符合Spring的生态，线程池由Spring统一管理，避免了手动创建线程池的资源泄漏风险。

关键注意事项 #

• 绝对不要在线程之间传递绑定到当前线程事务的Connection：Spring的事务资源（Connection、Session等）都是和线程上下文绑定的，跨线程使用必然会出现资源已被回收的错误。
• 线程池必须正确关闭：手动创建的ExecutorService一定要调用shutdown()或者shutdownNow()，避免线程资源泄漏。
• 事务超时时间：如果采用方案1（等待子线程），一定要调整@Transactional的timeout参数，确保超时时间足够子线程完成任务，比如@Transactional(timeout = 60)（单位：秒）。

内容的提问来源于stack exchange，提问作者johnny-b-goode