数据库事务隔离级别与 Spring 传播行为深度解析

现实案例：支付系统初期使用 SERIALIZABLE，TPS 仅为 50。后续根据业务特点拆分不同场景使用不同隔离级别，TPS 提升至 2000。

2. 四种隔离级别深度解析

2.1 并发问题三兄弟

理解三种并发问题是掌握隔离级别的前提：

-- 1. 脏读（Dirty Read）：读到未提交的数据
-- 事务 A
START TRANSACTION;
UPDATE users SET balance = balance - 100 WHERE id = 1;
-- 未提交
-- 事务 B（READ UNCOMMITTED）
START TRANSACTION;
SELECT balance FROM users WHERE id = 1;
-- 读到 -100，脏读！
COMMIT;

-- 2. 不可重复读（Non-Repeatable Read）：同一事务内两次读取结果不同
-- 事务 A
START TRANSACTION;
SELECT * FROM users WHERE id = 1;
-- 第一次读
-- 事务 B
UPDATE users SET name = 'Bob' WHERE id = 1;
COMMIT;
-- 事务 A
SELECT * FROM users WHERE id = 1;
-- 第二次读，结果变了！
COMMIT;

-- 3. 幻读（Phantom Read）：同一查询返回不同行数
-- 事务 A
START TRANSACTION;
SELECT COUNT(*) FROM users WHERE age > 18;
-- 返回 10
-- 事务 B
INSERT INTO users(name, age) VALUES ('Charlie', 20);
COMMIT;
-- 事务 A
SELECT COUNT(*) FROM users WHERE age > 18;
-- 返回 11，幻读！
COMMIT;

代码清单 2：三种并发问题示例

2.2 隔离级别对比

MySQL 支持的四种隔离级别如下：

-- 查看当前隔离级别
SELECT @@transaction_isolation;
-- 设置会话隔离级别
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
-- 四种级别对比
SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;   -- 可能脏读
SET TRANSACTION ISOLATION LEVEL READ COMMITTED;     -- 可能不可重复读
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;    -- 可能幻读（MySQL 用 MVCC 解决）
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;       -- 完全串行

注意：MySQL 的 REPEATABLE READ 通过 Next-Key Locks 解决了大部分幻读问题。

2.3 MVCC：隔离级别的实现核心

多版本并发控制（MVCC）是理解隔离级别的关键机制。

// MVCC 的简化实现原理
public class MVCCRecord {
    // 每个数据行有多个版本
    private long trxId;      // 创建该版本的事务 ID
    private long rollPointer;// 指向上一个版本的指针
    private Object data;     // 实际数据
    private boolean deleted; // 是否被删除
}

// 读取时的可见性判断
public boolean isVisible(long readViewTrxId, long recordTrxId) {
    // 1. 如果记录是由当前事务创建
    if (recordTrxId == readViewTrxId) {
        return !deleted; // 自己创建的可见（除非已删除）
    }
    // 2. 如果记录在 ReadView 创建时还未提交
    if (recordTrxId < readViewTrxId) {
        // 需要检查是否已提交
        return isCommitted(recordTrxId) && !deleted;
    }
    // 3. 如果记录在 ReadView 创建后才创建
    return false; // 不可见
}

代码清单 3：MVCC 实现原理

[图示：MVCC 多版本读取流程]

3. 锁机制：事务隔离的基石

3.1 MySQL 锁类型详解

-- 1. 行锁（Record Locks）
-- 锁住单行记录
SELECT * FROM users WHERE id = 1 FOR UPDATE;
-- 在 id=1 的记录上加 X 锁

-- 2. 间隙锁（Gap Locks）
-- 锁住一个范围，但不包括记录本身
SELECT * FROM users WHERE age BETWEEN 20 AND 30 FOR UPDATE;
-- 锁住 (20, 30) 这个区间

-- 3. Next-Key Locks = 行锁 + 间隙锁
-- MySQL 默认的锁，解决幻读
SELECT * FROM users WHERE id > 10 FOR UPDATE;
-- 锁住 (10, +∞) 整个范围

-- 4. 意向锁（Intention Locks）
-- 表级锁，表示'我想要加行锁'
-- IS: 意向共享锁
-- IX: 意向排他锁

代码清单 4：MySQL 锁类型

3.2 死锁分析与解决

死锁是事务中最棘手的问题之一。

-- 死锁案例
-- 事务 A
START TRANSACTION;
UPDATE account SET balance = balance - 100 WHERE id = 1;
-- 锁住 id=1
UPDATE account SET balance = balance + 100 WHERE id = 2;
-- 等待锁
-- 事务 B
START TRANSACTION;
UPDATE account SET balance = balance - 100 WHERE id = 2;
-- 锁住 id=2
UPDATE account SET balance = balance + 100 WHERE id = 1;
-- 等待锁，死锁！

[图示：死锁形成环]

解决方案：

// 1. 超时机制
@Transactional(timeout = 5)
public void transfer(Long from, Long to, BigDecimal amount) {
    // 业务逻辑
}

// 2. 死锁检测（MySQL 默认开启）
// 查看死锁日志
SHOW ENGINE INNODB STATUS;

// 3. 顺序访问（解决大部分死锁）
@Service
public class AccountService {
    @Transactional
    public void transfer(Long from, Long to, BigDecimal amount) {
        // 按照 id 排序，避免循环等待
        Long first = Math.min(from, to);
        Long second = Math.max(from, to);
        // 先锁小的，再锁大的
        accountRepository.lockById(first);
        accountRepository.lockById(second);
        // 执行业务
        accountRepository.deduct(first, amount);
        accountRepository.add(second, amount);
    }
}

代码清单 5：死锁解决方案

4. Spring 传播行为七剑客

4.1 传播行为定义

Spring 定义了 7 种传播行为，理解它们的关键在于事务的存在与否及新建策略。

public enum Propagation {
    REQUIRED,         // 有就加入，没有就新建
    SUPPORTS,         // 有就加入，没有就非事务运行
    MANDATORY,        // 必须有，没有就报错
    REQUIRES_NEW,     // 新建事务，挂起当前
    NOT_SUPPORTED,    // 非事务运行，挂起当前
    NEVER,            // 非事务运行，有事务就报错
    NESTED            // 嵌套事务
}

代码清单 6：Spring 传播行为枚举

4.2 实际工作流程

源码层面的处理逻辑如下：

public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager {
    private TransactionStatus handleExistingTransaction(
            TransactionDefinition definition, Object transaction, boolean debugEnabled)
            throws TransactionException {
        // 1. NEVER：有事务就报错
        if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
            throw new IllegalTransactionStateException(
                    "Existing transaction found for transaction marked with propagation 'never'");
        }
        // 2. NOT_SUPPORTED：挂起当前事务
        if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
            Object suspendedResources = suspend(transaction);
            boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
            return prepareTransactionStatus(definition, null, false, newSynchronization, debugEnabled, suspendedResources);
        }
        // 3. REQUIRES_NEW：挂起当前，创建新事务
        if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
            SuspendedResourcesHolder suspendedResources = suspend(transaction);
            try {
                return startTransaction(definition, transaction, debugEnabled, suspendedResources);
            } catch (RuntimeException | Error ex) {
                resume(transaction, suspendedResources);
                throw ex;
            }
        }
        // 4. NESTED：嵌套事务
        if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
            if (useSavepointForNestedTransaction()) {
                // 创建保存点
                Object savepoint = createSavepoint();
                return prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null, savepoint);
            } else {
                // 创建新事务
                return startTransaction(definition, transaction, debugEnabled, null);
            }
        }
        // 5. 其他情况（REQUIRED, SUPPORTS, MANDATORY）
        if (isValidateExistingTransaction()) {
            // 验证现有事务
        }
        prepareTransactionForPropagation(definition, transaction);
        return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
    }
}

代码清单 7：传播行为源码实现

[图示：传播行为决策流程]

4.3 实战测试

测试不同传播行为的效果：

@SpringBootTest
@Slf4j
class PropagationTest {
    @Autowired
    private UserService userService;
    @Autowired
    private LogService logService;

    @Test
    void testRequiredPropagation() {
        // 外层有事务
        userService.createUserWithLog("张三");
        // 验证：两个操作在同一个事务
        // 如果 logService.saveLog() 抛出异常，userService.createUser() 也会回滚
    }

    @Test
    void testRequiresNewPropagation() {
        // 内层新建事务
        userService.createUserWithSeparateLog("李四");
        // 验证：两个操作在不同事务
        // 如果 logService.saveLog() 抛出异常，不会影响 userService.createUser()
    }
}

@Service
class UserService {
    @Transactional(propagation = Propagation.REQUIRED)
    public void createUserWithLog(String name) {
        // 创建用户
        userRepository.save(new User(name));
        // 记录日志（REQUIRED：加入当前事务）
        logService.saveLog("用户创建：" + name);
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void createUserWithSeparateLog(String name) {
        // 创建用户
        userRepository.save(new User(name));
        // 记录日志（REQUIRES_NEW：新建事务）
        logService.saveLogInNewTransaction("用户创建：" + name);
    }
}

@Service
class LogService {
    @Transactional(propagation = Propagation.REQUIRED)
    public void saveLog(String message) {
        logRepository.save(new Log(message));
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void saveLogInNewTransaction(String message) {
        logRepository.save(new Log(message));
    }
}

代码清单 8：传播行为测试代码

5. 性能影响与优化

5.1 隔离级别性能测试

详细的性能测试数据如下：

测试环境：

• MySQL 8.0.28
• 4 核 8GB
• 100 并发线程
• 10 万测试数据

测试结果：

[图示：隔离级别性能对比]

5.2 传播行为性能测试

Spring 传播行为也有性能开销：

关键发现：

1. REQUIRES_NEW 创建新连接，开销最大
2. NESTED 在 MySQL 中实际是 REQUIRED（不支持真嵌套）
3. 无事务最快，但可能数据不一致

6. 企业级实战案例

6.1 电商订单支付系统

支付系统对事务要求最高，设计方案如下：

@Service
@Slf4j
public class PaymentService {
    @Autowired
    private AccountService accountService;
    @Autowired
    private OrderService orderService;
    @Autowired
    private TransactionTemplate transactionTemplate;

    // 方案 1：大事务（不推荐）
    @Transactional(
            isolation = Isolation.REPEATABLE_READ,
            propagation = Propagation.REQUIRED,
            rollbackFor = Exception.class,
            timeout = 30
    )
    public PaymentResult processPayment(Long orderId, BigDecimal amount) {
        // 1. 验证订单
        Order order = orderService.validateOrder(orderId, amount);
        // 2. 扣减库存（可能耗时）
        inventoryService.reduceStock(order.getItems());
        // 3. 扣款
        accountService.deduct(order.getUserId(), amount);
        // 4. 记录支付
        paymentRecordService.createRecord(orderId, amount);
        // 5. 更新订单状态
        orderService.updateStatus(orderId, OrderStatus.PAID);
        // 6. 发送消息（危险！）
        messageService.sendPaymentSuccess(order.getUserId(), orderId);
        return new PaymentResult(true, "支付成功");
    }

    // 方案 2：优化后的小事务（推荐）
    public PaymentResult processPaymentOptimized(Long orderId, BigDecimal amount) {
        // 阶段 1：验证和预留（快速完成）
        PaymentContext context = validateAndReserve(orderId, amount);
        // 阶段 2：异步处理后续
        CompletableFuture.runAsync(() -> processPaymentAsync(context));
        return new PaymentResult(true, "支付处理中");
    }

    @Transactional(
            isolation = Isolation.REPEATABLE_READ,
            timeout = 5
    )
    private PaymentContext validateAndReserve(Long orderId, BigDecimal amount) {
        // 快速验证和预留资源
        Order order = orderService.lockOrder(orderId);
        // 预扣库存（不实际扣减）
        inventoryService.reserveStock(order.getItems());
        // 冻结资金
        accountService.freeze(order.getUserId(), amount);
        return new PaymentContext(order, amount);
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void processPaymentAsync(PaymentContext context) {
        try {
            // 实际扣款
            accountService.deduct(context.getUserId(), context.getAmount());
            // 实际扣库存
            inventoryService.commitReserve(context.getItems());
            // 更新订单
            orderService.updateStatus(context.getOrderId(), OrderStatus.PAID);
            // 记录支付
            paymentRecordService.createRecord(
                    context.getOrderId(), context.getAmount());
        } catch (Exception e) {
            // 补偿处理
            compensationService.compensate(context);
            throw e;
        } finally {
            // 最终一致性：发消息
            transactionTemplate.execute(status -> {
                messageService.sendPaymentEvent(context);
                return null;
            });
        }
    }
}

代码清单 9：支付系统事务设计

优化效果对比：

6.2 批量数据处理

批量处理常见但容易出问题：

@Service
@Slf4j
public class BatchProcessService {
    // 错误：大事务处理所有数据
    @Transactional
    public void processAllUsers() {
        List<User> users = userRepository.findAll();
        for (User user : users) {
            processUser(user); // 循环内处理
        }
    }

    // 正确：分批处理
    public void processUsersInBatch() {
        int page = 0;
        int size = 100;
        Page<User> userPage;
        do {
            // 每批一个事务
            userPage = userRepository.findAll(PageRequest.of(page, size));
            processUserBatch(userPage.getContent());
            page++;
        } while (userPage.hasNext());
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void processUserBatch(List<User> users) {
        for (User user : users) {
            try {
                processUser(user);
            } catch (Exception e) {
                // 记录失败，继续处理其他
                log.error("处理用户失败：{}", user.getId(), e);
            }
        }
    }

    // 使用编程式事务
    @Autowired
    private TransactionTemplate transactionTemplate;

    public void processWithProgrammaticTransaction() {
        transactionTemplate.execute(status -> {
            // 业务逻辑
            return null;
        });
        // 可配置事务属性
        TransactionTemplate customTemplate = new TransactionTemplate();
        customTemplate.setPropagationBehavior(Propagation.REQUIRES_NEW.value());
        customTemplate.setIsolationLevel(Isolation.READ_COMMITTED.value());
        customTemplate.setTimeout(30);
    }
}

代码清单 10：批量事务处理优化

7. 监控与故障排查

7.1 事务监控配置

# application.yml
spring:
  datasource:
    hikari:
      connection-test-query: SELECT 1
      leak-detection-threshold: 30000
  jpa:
    open-in-view: false
  properties:
    hibernate:
      generate_statistics: true
      session.events.log.LOG_QUERIES_SLOWER_THAN_MS: 1000
  management:
    endpoints:
      web:
        exposure:
          include: health,metrics,prometheus,transactions

7.2 事务监控代码

@Component
@Slf4j
public class TransactionMonitor {
    @Autowired
    private PlatformTransactionManager transactionManager;

    // 监控事务状态
    @Scheduled(fixedDelay = 30000)
    public void monitorTransactions() {
        if (transactionManager instanceof DataSourceTransactionManager) {
            DataSourceTransactionManager dsTm = (DataSourceTransactionManager) transactionManager;
            // 获取活跃事务数
            int active = getActiveTransactionCount();
            int idle = getIdleConnectionCount();
            if (active > 10) {
                log.warn("活跃事务过多：{}", active);
                // 发送告警
            }
            if ((double) active / (active + idle) > 0.8) {
                log.warn("连接池使用率过高：{}/{}", active, active + idle);
            }
        }
    }

    // 死锁检测
    public void checkDeadlocks() {
        // 查询 MySQL 死锁日志
        // SHOW ENGINE INNODB STATUS
        // 或者使用 JDBC
        try (Connection conn = dataSource.getConnection();
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SHOW ENGINE INNODB STATUS")) {
            if (rs.next()) {
                String status = rs.getString("Status");
                if (status.contains("LATEST DETECTED DEADLOCK")) {
                    log.error("检测到死锁：{}", status);
                    alertService.sendDeadlockAlert(status);
                }
            }
        }
    }
}

代码清单 11：事务监控代码

7.3 慢事务排查

-- 1. 查看当前运行的事务
SELECT * FROM information_schema.innodb_trx\G

-- 2. 查看锁信息
SELECT * FROM information_schema.innodb_locks\G
SELECT * FROM information_schema.innodb_lock_waits\G

-- 3. 查看进程列表
SHOW PROCESSLIST;

-- 4. 查看慢查询
SELECT * FROM mysql.slow_log
WHERE start_time > NOW() - INTERVAL 1 HOUR
ORDER BY query_time DESC LIMIT 10;

-- 5. 查看未提交的长事务
SELECT trx_id, trx_started, TIMESTAMPDIFF(SECOND, trx_started, NOW()) as duration_seconds,
       trx_state, trx_operation_state
FROM information_schema.innodb_trx
WHERE trx_state = 'RUNNING'
ORDER BY trx_started ASC;

8. 最佳实践总结

8.1 事务最佳实践

经过多年实战，总结的事务最佳实践如下：

📜 第一条：合理选择隔离级别

• 查询用 READ_COMMITTED
• 支付用 REPEATABLE_READ
• 报表用 READ_UNCOMMITTED
• 特殊场景用 SERIALIZABLE

📜 第二条：正确使用传播行为

• 默认用 REQUIRED
• 独立操作用 REQUIRES_NEW
• 只读操作用 SUPPORTS
• 日志记录用 NOT_SUPPORTED

📜 第三条：控制事务粒度

• 事务要短小（<1 秒）
• 避免事务中 RPC 调用
• 批量操作要分页
• 及时提交事务

📜 第四条：做好监控告警

• 监控长事务
• 监控死锁
• 监控连接池
• 设置合理超时

8.2 生产环境配置

# application-prod.yml
spring:
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      connection-timeout: 5000
      idle-timeout: 600000
      max-lifetime: 1800000
      leak-detection-threshold: 30000
  transaction:
    default-timeout: 30
    rollback-on-commit-failure: true

// 事务管理器配置
@Configuration
@EnableTransactionManagement
public class TransactionConfig {
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        DataSourceTransactionManager tm = new DataSourceTransactionManager(dataSource);
        tm.setDefaultTimeout(30);
        tm.setNestedTransactionAllowed(true);
        tm.setRollbackOnCommitFailure(true);
        return tm;
    }
}

9. 常见问题解决方案

9.1 事务不生效的 7 个原因

// 1. 方法不是 public
@Transactional
private void privateMethod() {
    // 不生效！
    // ...
}

// 2. 自调用问题
@Service
public class UserService {
    public void createUser(User user) {
        validateAndSave(user); // 自调用，事务不生效！
    }

    @Transactional
    public void validateAndSave(User user) {
        // ...
    }

    // 解决方案：注入自己
    @Autowired
    private UserService self;

    public void createUserFixed(User user) {
        self.validateAndSave(user); // 通过代理调用
    }
}

// 3. 异常类型不匹配
@Transactional
// 默认只回滚 RuntimeException
public void saveData() throws Exception {
    throw new Exception("业务异常"); // 不会回滚！
}

// 正确
@Transactional(rollbackFor = Exception.class)
public void saveData() throws Exception {
    throw new Exception("业务异常"); // 会回滚
}

// 4. 多数据源配置错误
// 5. 事务管理器配置错误
// 6. 嵌套事务配置
// 7. 超时设置不合理

9.2 死锁预防方案

@Service
public class AccountService {
    // 方案 1：顺序访问
    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void transfer(Long from, Long to, BigDecimal amount) {
        Long first = Math.min(from, to);
        Long second = Math.max(from, to);
        // 按照固定顺序加锁
        lockAccount(first);
        lockAccount(second);
        // 执行业务
        deduct(first, amount);
        add(second, amount);
    }

    // 方案 2：乐观锁
    @Transactional
    public boolean transferWithOptimisticLock(Long from, Long to, BigDecimal amount) {
        int retry = 0;
        while (retry < 3) {
            Account fromAccount = accountRepository.findById(from).get();
            Account toAccount = accountRepository.findById(to).get();
            if (fromAccount.getBalance().compareTo(amount) < 0) {
                throw new InsufficientBalanceException();
            }
            fromAccount.setBalance(fromAccount.getBalance().subtract(amount));
            toAccount.setBalance(toAccount.getBalance().add(amount));
            fromAccount.setVersion(fromAccount.getVersion() + 1);
            toAccount.setVersion(toAccount.getVersion() + 1);
            try {
                accountRepository.saveAll(Arrays.asList(fromAccount, toAccount));
                return true;
            } catch (ObjectOptimisticLockingFailureException e) {
                retry++;
                if (retry >= 3) {
                    throw new ConcurrentUpdateException("转账失败，请重试");
                }
            }
        }
        return false;
    }

    // 方案 3：设置死锁超时
    @Transactional(timeout = 5)
    // 5 秒超时
    public void transferWithTimeout(Long from, Long to, BigDecimal amount) {
        // 业务逻辑
    }
}

代码清单 12：死锁预防方案