小鹿记录

菜单

Administrator
发布于 2025-02-24 / 8 阅读
0
0

长事务

长事务

背景

报销项目属于公司内部项目，本身是没什么高并发的，系统也一直稳定运行着。

在年末的一天下午（前几天刚好下了大雪，打车的人特别多），公司发通知邮件说年度报销窗口即将关闭，需要尽快将未报销的费用报销掉，而刚好那天工作流引擎在进行安全加固。

收到邮件后报销的人开始逐渐增多，在接近下班的时候到达顶峰，此时报销系统开始出现了故障：数据库监控平台一直收到告警短信，数据库连接不足，出现大量死锁；日志显示调用流程引擎接口出现大量超时；同时一直提示CannotGetJdbcConnectionException，数据库连接池连接占满。

在发生故障后，我们尝试过杀掉死锁进程，也进行过暴力重启，只是不到10分钟故障再次出现，收到大量电话投诉。
最后没办法只能向全员发送停机维护邮件并发送故障报告，而后，绩效被打了个D，惨...。

原因分析

我们知道@Transactional 注解，是使用 AOP 实现的，本质就是在目标方法执行前后进行拦截。在目标方法执行前加入或创建一个事务，在执行方法执行后，根据实际情况选择提交或是回滚事务。

当 Spring 遇到该注解时，会自动从数据库连接池中获取 connection，并开启事务然后绑定到 ThreadLocal 上，对于@Transactional注解包裹的整个方法都是使用同一个connection连接。如果我们出现了耗时的操作，比如第三方接口调用，业务逻辑复杂，大批量数据处理等就会导致我们我们占用这个connection的时间会很长，数据库连接一直被占用不释放。一旦类似操作过多，就会导致数据库连接池耗尽。

在一个事务中执行RPC操作导致数据库连接池撑爆属于是典型的长事务问题，类似的操作还有在事务中进行大量数据查询，业务规则处理等...

定义

何为长事务？

顾名思义就是运行时间比较长，长时间未提交的事务，也可以称之为大事务。

危害

长事务会引发哪些问题？

长事务引发的常见危害有：

  1. 数据库连接池被占满，应用无法获取连接资源；
  2. 容易引发数据库死锁；
  3. 数据库回滚时间长；
  4. 在主从架构中会导致主从延时变大。

如何避免长事务

既然知道了长事务的危害，那如何在开发中避免出现长事务问题呢？

很明显，解决长事务的宗旨就是 对事务方法进行拆分，尽量让事务变小，变快，减小事务的颗粒度。

既然提到了事务的颗粒度，我们就先回顾一下Spring进行事务管理的方式。

声明式事务

首先我们要知道，通过在方法上使用@Transactional注解进行事务管理的操作叫声明式事务 。

使用声明式事务的优点 很明显，就是使用很简单，可以自动帮我们进行事务的开启、提交以及回滚等操作。使用这种方式，程序员只需要关注业务逻辑就可以了。

声明式事务有一个最大的缺点，就是事务的颗粒度是整个方法，无法进行精细化控制。

与声明式事务对应的就是编程式事务。

基于底层的API，开发者在代码中手动的管理事务的开启、提交、回滚等操作。在spring项目中可以使用TransactionTemplate类的对象，手动控制事务。

@Autowired 
private TransactionTemplate transactionTemplate; 
 
... 
 
public void save(RequestBill requestBill) { 
    transactionTemplate.execute(transactionStatus -> {
        requestBillDao.save(requestBill);
        //保存明细表
        requestDetailDao.save(requestBill.getDetail());
        return Boolean.TRUE; 
    });
}

使用编程式事务最大的好处就是可以精细化控制事务范围。

所以避免长事务最简单的方法就是不要使用声明式事务@Transactional，而是使用编程式事务手动控制事务范围。

使用@Transactional，又能避免产生长事务

有的同学会说，@Transactional使用这么简单，有没有办法既可以使用@Transactional，又能避免产生长事务？

那就需要对方法进行拆分，将不需要事务管理的逻辑与事务操作分开：

@Service
public class OrderService{
 
    public void createOrder(OrderCreateDTO createDTO){
        query();
        validate();
        saveData(createDTO);
    }
  
  //事务操作
    @Transactional(rollbackFor = Throwable.class)
    public void saveData(OrderCreateDTO createDTO){
        orderDao.insert(createDTO);
    }
}

query()与validate()不需要事务，我们将其与事务方法saveData()拆开。

当然，这种拆分会命中使用@Transactional注解时事务不生效的经典场景，很多新手非常容易犯这个错误。@Transactional注解的声明式事务是通过spring aop起作用的，而spring aop需要生成代理对象，直接在同一个类中方法调用使用的还是原始对象，事务不生效。

其他几个常见的事务不生效的场景为：

  • @Transactional 应用在非 public 修饰的方法上
  • @Transactional 注解属性 propagation 设置错误
  • @Transactional 注解属性 rollbackFor 设置错误
  • 同一个类中方法调用，导致@Transactional失效
  • 异常被catch捕获导致@Transactional失效

正确的拆分方法应该使用下面两种：

  1. 可以将方法放入另一个类，如新增 manager层，通过spring注入，这样符合了在对象之间调用的条件。
@Service
public class OrderService{
  
    @Autowired
   private OrderManager orderManager;
 
    public void createOrder(OrderCreateDTO createDTO){
        query();
        validate();
        orderManager.saveData(createDTO);
    }
}
 
@Service
public class OrderManager{
  
    @Autowired
   private OrderDao orderDao;
  
  @Transactional(rollbackFor = Throwable.class)
    public void saveData(OrderCreateDTO createDTO){
        orderDao.saveData(createDTO);
    }
}
  1. 启动类添加@EnableAspectJAutoProxy(exposeProxy = true)，方法内使用AopContext.currentProxy()获得代理类，使用事务。
SpringBootApplication.java
 
@EnableAspectJAutoProxy(exposeProxy = true)
@SpringBootApplication
public class SpringBootApplication {}




OrderService.java
  
public void createOrder(OrderCreateDTO createDTO){
    OrderService orderService = (OrderService)AopContext.currentProxy();
    orderService.saveData(createDTO);
}

给长事务，设置超时时间

在 Spring Boot 中处理长事务并设置超时时间，可通过以下 5 种方式实现，结合不同场景灵活选择：

一、注解方式配置事务超时

通过 @Transactional(timeout = N) 注解直接设置事务超时时间（单位：秒）：

@Transactional(timeout = 30)  // 设置事务最长执行30秒
public void processLongTransaction() {
    // 包含数据库操作和其他耗时逻辑
    jdbcTemplate.execute("...");
    externalService.callSlowAPI();
}

注意：超时计时从事务开始到提交/回滚结束，包含所有数据库操作和非数据库操作。若事务中混合休眠等非数据库操作，可能导致超时异常。

二、编程式事务超时控制

适用于需要动态调整超时时间的场景：

  1. 使用 TransactionTemplate
@Autowired
private PlatformTransactionManager transactionManager;

public void executeWithTimeout() {
    TransactionTemplate template = new TransactionTemplate(transactionManager);
    template.setTimeout(60);  // 设置60秒超时
    template.execute(status -> {
        // 业务逻辑
        return null;
    });
}
  1. 通过 DefaultTransactionDefinition
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setTimeout(120);  // 设置120秒超时
TransactionStatus status = transactionManager.getTransaction(def);
try {
    // 业务逻辑
    transactionManager.commit(status);
} catch (Exception e) {
    transactionManager.rollback(status);
}

三、全局事务管理器配置

在数据源配置中设置默认超时时间（XML 或 JavaConfig）：

@Bean
public DataSourceTransactionManager transactionManager(DataSource dataSource) {
    DataSourceTransactionManager tm = new DataSourceTransactionManager(dataSource);
    tm.setDefaultTimeout(45);  // 全局默认45秒超时
    return tm;
}

此配置对所有未显式设置超时的事务生效，适合统一管理超时策略。


也可以在application.yaml配置文件中，设置全局事务超时时间，如下：

spring:
  transaction:
    default-timeout: 60s

四、异常处理机制

捕获 TransactionTimedOutException 实现友好提示：

@ExceptionHandler(TransactionTimedOutException.class)
public ResponseEntity<String> handleTimeout(TransactionTimedOutException ex) {
    return ResponseEntity.status(HttpStatus.REQUEST_TIMEOUT)
           .body("操作超时，请简化请求或稍后重试");
}

五、注意事项与优化建议

  1. 超时触发条件
    超时时间包括：数据库操作 + Java 代码执行时间 + 网络延迟（分布式事务）

  2. 长事务优化策略

    • 拆分大事务为多个小事务
    • 结合异步处理（如 @Async + Future 设置异步超时）
    • 避免在事务中执行远程调用或文件 IO

  3. 特殊场景处理

    • JTA 分布式事务需通过 <property name="defaultTimeout" value="60"/> 配置
    • 与 Resilience4j 结合实现熔断降级

配置对比表

方式适用场景粒度优先级
@Transactional方法级控制细粒度最高
编程式事务动态调整参数中等粒度次高
事务管理器全局配置统一默认值粗粒度最低

建议优先使用注解方式，复杂场景结合编程式事务。若需获取完整配置案例，可参考文献中的实战代码。

超时，自动中断事务并抛出异常

在 Spring 事务管理中，当事务执行时间超过预设的超时时间时，系统会自动中断事务并抛出异常。以下是具体机制和异常处理细节：

一、超时后的自动中断与回滚

  1. 事务自动回滚
    当超时发生时，Spring 会强制终止当前事务并触发回滚操作，确保未完成的操作不会提交到数据库，避免数据不一致。

    • 底层机制：事务管理器（如 JpaTransactionManager）会监控事务执行时间，超时后主动调用回滚逻辑。
    • 适用场景：适用于数据库查询阻塞、外部服务响应延迟等导致事务长时间未完成的场景。

  2. 事务中断的触发条件

    • 超时计时从事务开始（获取数据库连接）到提交/回滚结束，包含所有数据库操作和非数据库代码执行时间。
    • 若事务中混合了数据库操作和非阻塞代码（如 Thread.sleep()），超时仍会触发回滚。

二、抛出的异常类型

  1. 默认异常：TransactionTimedOutException

    • 这是 Spring 事务超时的标准异常，继承自 RuntimeException，表示事务因超时被强制回滚。

    • 捕获示例：

      @ExceptionHandler(TransactionTimedOutException.class)
public ResponseEntity<String> handleTimeout(TransactionTimedOutException ex) {
    return ResponseEntity.status(504).body("事务超时: " + ex.getMessage());
}

  2. 底层驱动异常

    • 若超时由数据库驱动触发（如 MySQL 的 innodb_lock_wait_timeout），可能抛出 SQLException 或其子类（如 MySQLTimeoutException），最终被 Spring 包装为 UncategorizedSQLException。
    • 示例：在低层 JDBC 操作超时的情况下，可能先抛出 MySQLTimeoutException，随后 Spring 将其转换为事务异常。

  3. 连接关闭导致的异常

    • 若通过 JDBC 驱动设置 Socket 超时（如 oracle.net.READ_TIMEOUT），超时后连接会被强制关闭，抛出 SQLException: Connection closed，最终触发 TransactionSystemException。

三、配置与验证建议

  1. 超时设置方式

    • 注解配置：@Transactional(timeout = 30)（单位：秒）。
    • 全局配置：通过 JpaTransactionManager.setDefaultTimeout(30) 或配置文件 spring.transaction.default-timeout=30s（需 Spring Boot ≥2.3.0）。

  2. 验证方法

    • 日志监控：启用 DEBUG 级别日志观察事务生命周期：

      logging.level.org.springframework.transaction=DEBUG

    • 单元测试：模拟长耗时操作（如 TimeUnit.SECONDS.sleep(35)），验证是否触发超时异常。

四、注意事项

  1. 优先级规则
    方法级注解超时 > 编程式事务超时 > 全局默认超时。

  2. 数据库兼容性

    • 部分数据库（如 MySQL）需配置 innodb_lock_wait_timeout 与事务超时时间匹配，避免冲突。
    • 使用 ORM 框架（如 MyBatis）时，需额外配置语句级超时（如 defaultStatementTimeout）。

  3. 分布式事务差异
    JTA 分布式事务需通过 <property name="defaultTimeout"> 配置，且依赖底层容器支持。

总结

当 Spring 事务超时后，系统会自动中断并回滚事务，同时抛出 TransactionTimedOutException 或底层驱动的包装异常。开发者需根据业务需求合理设置超时时间，并通过异常处理机制实现友好提示或降级逻辑。

事务超时时间计算

Spring事务超时 = 事务开始时到最后一个Statement创建时时间 + 最后一个Statement的执行时超时时间（即其queryTimeout）。

假设事务超时时间设置为2秒；假设sql执行时间为1秒；

如下调用是事务不超时的

public void testTimeout() throws InterruptedException {  
    System.out.println(System.currentTimeMillis());  
    JdbcTemplate jdbcTemplate = new JdbcTemplate(ds);  
    jdbcTemplate.execute(" update test set hobby = hobby || '1'");  
    System.out.println(System.currentTimeMillis());  
    Thread.sleep(3000L);  
}

而如下事务超时是起作用的；

public void testTimeout() throws InterruptedException {  
    Thread.sleep(3000L);  
    System.out.println(System.currentTimeMillis());  
    JdbcTemplate jdbcTemplate = new JdbcTemplate(ds);  
    jdbcTemplate.execute(" update test set hobby = hobby || '1'");  
    System.out.println(System.currentTimeMillis());  
}
TryCatch异常捕获
SqlAdvanceUse

评论