MySQL 事务隔离与 MVCC:快照读、当前读与间隙锁

MySQL 事务隔离与 MVCC:快照读、当前读与间隙锁

Hello,我是小兔大白糖。 读完能区分快照读与当前读,并解释 RR/RC 下 Read View 与幻读防护的直觉边界。

MVCC用版本链做快照读;当前读走锁。RR/RC 的幻读防护边界不同,不要混用口诀。

估计阅读时间:34 分钟

快照读与当前读对照
快照读与当前读对照 · 点击查看 SVG 原图

一句话结论是什么?

MySQL InnoDB 通过 MVCC(多版本并发控制) 实现快照读的高并发免锁访问,通过 行锁 + 间隙锁(Gap Lock)+ 临键锁(Next-Key Lock) 实现当前读的隔离性保证。READ COMMITTED 每次查询生成新 Read View,REPEATABLE READ 事务开始时生成唯一 Read View,这是二者在不可重复读/幻读表现上的根本差异。死锁本质是事务间资源循环等待,可通过 show engine innodb status 快速定位,并通过调整索引、缩短事务、反向加锁顺序化解。


1. 这是什么?概念怎么定义

1.1 ACID:事务的四个承诺

特性英文实现机制一句话解释
原子性Atomicityundo log(回滚日志)要么全做,要么全不做,像原子一样不可分割
一致性Consistency最终目标(由其他三个特性共同保障)数据从一种合法状态变为另一种合法状态
隔离性IsolationMVCC + 锁机制并发事务互不干扰,如同串行执行
持久性Durabilityredo log(重做日志)+ Double Write Buffer提交后数据永久保存,即使数据库崩溃

类比理解:事务就像银行保险箱的一次完整操作。原子性是"操作不可中断";一致性是"总金额不变";隔离性是"多个客户同时操作不同保险箱互不干扰";持久性是"操作完成后即使银行停电,记录也永久保留"。

1.2 隔离级别与并发问题

SQL 标准定义了四种隔离级别,以及每种级别可能遇到的三种并发读问题:

隔离级别脏读 (Dirty Read)不可重复读 (Non-repeatable Read)幻读 (Phantom Read)
READ UNCOMMITTED (RU)可能可能可能
READ COMMITTED (RC)不可能可能可能
REPEATABLE READ (RR)不可能不可能可能*
SERIALIZABLE不可能不可能不可能

*MySQL InnoDB 的 RR 通过 MVCC + Next-Key Lock 部分解决了幻读(快照读完全解决,当前读通过锁解决),但严格意义上仍存在特殊场景的幻读,后文详述。

三种并发问题的精确定义:

  • 脏读:事务 A 读取了事务 B 未提交的修改,B 回滚后 A 读到的是"脏数据"。
  • 不可重复读:事务 A 内 两次相同条件查询 结果不一致,因为事务 B 在中间提交了 UPDATE/DELETE。
  • 幻读:事务 A 内 两次相同范围查询 结果集的行数不一致,因为事务 B 在中间提交了 INSERT(或 DELETE 后 INSERT)。

关键区分:不可重复读是 行内容变了;幻读是 行数变了(多了或少了行)。

1.3 为什么需要 MVCC

在没有 MVCC 的数据库中(如 MySQL MyISAM 或旧版 SQL Server),读操作必须加共享锁(S Lock),读写互相阻塞,并发性能极差。MVCC 的核心思想是 "读写互不阻塞" —— 读操作读取的是数据的历史版本快照,不需要等待写操作释放锁。

类比:MVCC 就像 Git 的版本控制系统。多人可以同时查看代码的不同历史版本(commit),而不会阻塞正在提交新代码的人。每个读者看到的是自己"快照"时刻的代码库状态。


2. 核心原理是什么?

核心原理:MVCC 用版本链做快照读;当前读走锁;隔离级别决定 Read View 与幻读防护边界。

2.1 MVCC 的三要素

MVCC 的实现依赖三个核心机制:

  1. undo log(回滚日志):保存数据修改前的历史版本,形成版本链
  2. 行隐藏字段:每行记录包含 DB_TRX_ID(最后修改事务 ID)和 DB_ROLL_PTR(指向 undo log 的指针)
  3. Read View(一致性视图):快照读时判断可见性的逻辑数据结构

行记录的隐藏字段

+----------+----------+----------+-------------+-------------+
| DB_ROW_ID| DB_TRX_ID| DB_ROLL_P|  col1       |  col2       |
| (隐式主键)| (事务ID)  | (回滚指针)|  (用户数据)  |  (用户数据)  |
+----------+----------+----------+-------------+-------------+
  • DB_TRX_ID(6 bytes):最后修改这条记录的事务 ID
  • DB_ROLL_PTR(7 bytes):指向 undo log 中上一个版本的指针
  • DB_ROW_ID(6 bytes):隐式主键(当表没有显式主键时生成)

undo log 版本链

当一行数据被多次修改时,undo log 会形成一条版本链(Version Chain):

当前行 (DB_TRX_ID=100)
    |
    v
undo log (TRX_ID=80, 修改前的值)  <-- Read View 可能读取到这里
    |
    v
undo log (TRX_ID=50, 更早的值)
    |
    v
   ...

注意:undo log 中的旧版本数据不能无限增长。当没有事务需要读取这些旧版本时(即比所有活跃事务的 min_trx_id 都小),由 Purge 线程 异步清理。

2.2 Read View 的可见性判断算法

Read View 是事务执行快照读时生成的一个逻辑视图,包含四个核心字段:

字段含义
creator_trx_id创建该 Read View 的事务 ID
m_ids生成 Read View 时,所有 活跃(未提交) 事务的 ID 集合
min_trx_idm_ids 中的最小值
max_trx_id生成 Read View 时,系统将要分配的下一个事务 ID(即 max_trx_id = 当前最大已分配ID + 1)

可见性判断规则(针对数据行的 DB_TRX_ID):

IF DB_TRX_ID == creator_trx_id:
    可见(自己修改的,当然可见)
ELSE IF DB_TRX_ID < min_trx_id:
    可见(修改的事务已提交,且在 Read View 创建前提交)
ELSE IF DB_TRX_ID >= max_trx_id:
    不可见(修改的事务在 Read View 创建后才启动)
ELSE IF DB_TRX_ID IN m_ids:
    不可见(修改的事务在 Read View 创建时仍是活跃的,未提交)
ELSE:
    可见(修改的事务在 Read View 创建时已提交)

如果当前版本不可见,就沿着 DB_ROLL_PTR 指针找上一个版本,直到找到可见版本或到达链尾。

2.3 RC vs RR 的本质差异

这是面试中最容易被追问的核心点:

特性READ COMMITTED (RC)REPEATABLE READ (RR)
Read View 生成时机每条 SELECT 语句执行时都生成新的 Read View事务第一次 SELECT 时生成一个 Read View,事务期间复用
不可重复读可能(两次 SELECT 之间其他事务提交,新 Read View 能看到)不可能(始终是同一个 Read View)
幻读(快照读)可能不可能(同一个 Read View 看不到新插入的行)
幻读(当前读)可能可能(通过 Next-Key Lock 解决)

类比:RC 就像每次查看账本时都重新打印一份最新账本,可能看到中间被修改的内容;RR 就像事务开始时拍了一张照片,整个事务期间只看这张照片,外界的变化不影响你看到的画面。

2.4 当前读 vs 快照读

类型名称实现方式SQL 示例
快照读Snapshot Read / Consistent Nonlocking ReadMVCC,不加锁普通 SELECT
当前读Current Read / Locking Read加锁(S Lock 或 X Lock)SELECT ... FOR UPDATE、SELECT ... LOCK IN SHARE MODE、INSERT、UPDATE、DELETE

关键理解:

  • UPDATE、DELETE、INSERT 在执行前需要先执行当前读(找到要修改的行并加锁),然后修改。
  • RR 下 SELECT ... FOR UPDATE 通过 Next-Key Lock(行锁 + 间隙锁)来防止幻读。

2.5 InnoDB 锁机制详解

InnoDB 的锁按粒度分为:

InnoDB Locks
├── 行级锁 (Row-level)
│   ├── 共享锁 (S Lock / Shared Lock)
│   ├── 排他锁 (X Lock / Exclusive Lock)
│   ├── 意向共享锁 (IS Lock)
│   ├── 意向排他锁 (IX Lock)
│   ├── 记录锁 (Record Lock): 锁定单条索引记录
│   ├── 间隙锁 (Gap Lock): 锁定索引记录之间的"间隙"
│   └── 临键锁 (Next-Key Lock): Record Lock + Gap Lock = 锁定记录及其前面的间隙
│
└── 表级锁 (Table-level)
    ├── AUTO-INC Lock(自增锁)
    └── MDL(Metadata Lock,元数据锁,Server 层实现)

Next-Key Lock 与幻读

Next-Key Lock 是 InnoDB 在 RR 隔离级别下防止幻读的核心武器:

-- 假设表 t 的 id 列上有索引,现有记录 id=5, 10, 15
-- 事务 A 执行:
SELECT * FROM t WHERE id > 5 AND id < 15 FOR UPDATE;
 
-- 加锁范围:(5, 10] + (10, 15] = (5, 15]
-- 即锁住 id 在 5 到 15 之间的所有记录以及间隙
 
-- 此时事务 B 执行以下操作都会被阻塞:
INSERT INTO t VALUES (8);  -- 8 落在 (5,15) 间隙内,被 Gap Lock 阻塞
INSERT INTO t VALUES (12); -- 同上
UPDATE t SET ... WHERE id = 10; -- 被 Record Lock 阻塞

注意:如果查询条件没有命中索引,RR 下会导致 全表扫描并锁住所有记录 + 所有间隙,性能灾难。这就是为什么所有生产环境的 SQL 都必须有合适的索引。

2.6 死锁:循环等待的四个条件

死锁产生的四个必要条件(Coffman 条件):

  1. 互斥条件:资源一次只能被一个事务占用(行锁的排他性)
  2. 占有且等待:事务已持有至少一个资源,同时请求新的资源
  3. 不可抢占:已获得的资源不能被强制剥夺,只能由持有者主动释放
  4. 循环等待:事务之间形成首尾相接的等待链

类比:死锁就像四条车道交汇的环形路口,每辆车都占了前面的路又等着前面的车让路,结果谁都动不了。

死锁排查实战

-- 1. 查看最近一次死锁信息
SHOW ENGINE INNODB STATUS;
 
-- 重点关注 LATEST DETECTED DEADLOCK 部分:
-- *** (1) TRANSACTION: 事务1持有的锁和等待的锁
-- *** (2) TRANSACTION: 事务2持有的锁和等待的锁
-- *** WE ROLL BACK TRANSACTION (1): 被回滚的事务
 
-- 2. 查看当前事务和锁等待
SELECT
    r.trx_id waiting_trx_id,
    r.trx_mysql_thread_id waiting_thread,
    r.trx_query waiting_query,
    b.trx_id blocking_trx_id,
    b.trx_mysql_thread_id blocking_thread,
    b.trx_query blocking_query
FROM information_schema.innodb_lock_waits w
INNER JOIN information_schema.innodb_trx b ON b.trx_id = w.blocking_trx_id
INNER JOIN information_schema.innodb_trx r ON r.trx_id = w.requesting_trx_id;
 
-- 3. 查看锁的详细信息
SELECT * FROM information_schema.innodb_locks;
SELECT * FROM performance_schema.data_locks;  -- MySQL 8.0+
SELECT * FROM performance_schema.data_lock_waits;  -- MySQL 8.0+

死锁日志解读示例:

------------------------
LATEST DETECTED DEADLOCK
------------------------
*** (1) TRANSACTION:
TRANSACTION 4217, ACTIVE 1 sec starting index read
mysql tables in use 1, locked 1
LOCK WAIT 3 lock struct(s), heap size 1136, 2 row lock(s)
MySQL thread id 10, OS thread handle 123145302315008, query id 123 localhost root updating
UPDATE accounts SET balance = balance - 100 WHERE id = 1
*** (1) WAITING FOR THIS LOCK TO BE GRANTED:
RECORD LOCKS space id 24 page no 3 n bits 72 index PRIMARY of table `test`.`accounts` trx id 4217 lock_mode X locks rec but not gap waiting

*** (2) TRANSACTION:
TRANSACTION 4218, ACTIVE 1 sec starting index read
mysql tables in use 1, locked 1
3 lock struct(s), heap size 1136, 2 row lock(s)
MySQL thread id 11, OS thread handle 123145303851520, query id 124 localhost root updating
UPDATE accounts SET balance = balance - 200 WHERE id = 2
*** (2) HOLDS THE LOCK(S):
RECORD LOCKS space id 24 page no 3 n bits 72 index PRIMARY of table `test`.`accounts` trx id 4218 lock_mode X locks rec but not gap

*** (2) WAITING FOR THIS LOCK TO BE GRANTED:
RECORD LOCKS space id 24 page no 3 n bits 72 index PRIMARY of table `test`.`accounts` trx id 4218 lock_mode X locks rec but not gap waiting

*** WE ROLL BACK TRANSACTION (1)

解读:事务 4217 持有 id=2 的锁,等待 id=1 的锁;事务 4218 持有 id=1 的锁,等待 id=2 的锁。形成循环等待,InnoDB 选择回滚事务 4217(通常是修改行数较少或权重较低的事务)。

2.7 图解:MVCC 读取流程

mysql mvcc isolation · 图 2
mysql mvcc isolation · 图 2 · 点击查看 SVG 原图

2.8 图解:InnoDB 锁兼容矩阵与死锁形成

mysql mvcc isolation · 图 3
mysql mvcc isolation · 图 3 · 点击查看 SVG 原图

3. 怎么用?关键代码与配置

3.1 悲观锁库存扣减(Pessimistic Locking)

适用场景:高并发竞争激烈的库存扣减、资金扣减。先加锁,再操作,保证强一致性。

@Service
@RequiredArgsConstructor
public class PessimisticInventoryService {
 
    private final JdbcTemplate jdbcTemplate;
 
    /**
     * 悲观锁扣减库存
     * 适用场景:秒杀、抢购等并发极高且冲突频繁的场景
     * 核心:SELECT ... FOR UPDATE 在事务内加排他锁,阻塞其他事务
     */
    @Transactional(isolation = Isolation.REPEATABLE_READ)
    public boolean deductInventory(Long productId, Integer quantity) {
        // Step 1: 加排他锁并读取当前库存
        // FOR UPDATE 会在索引记录上加 X Lock,其他事务的 FOR UPDATE/UPDATE/DELETE 都会阻塞
        String selectSql = """
            SELECT id, available_stock, reserved_stock, version
            FROM t_inventory
            WHERE product_id = ?
            FOR UPDATE
            """;
 
        Inventory inventory = jdbcTemplate.queryForObject(selectSql,
            (rs, rowNum) -> new Inventory(
                rs.getLong("id"),
                rs.getInt("available_stock"),
                rs.getInt("reserved_stock"),
                rs.getLong("version")
            ),
            productId
        );
 
        if (inventory == null || inventory.availableStock() < quantity) {
            log.warn("库存不足或不存在, productId={}, required={}, available={}",
                productId, quantity, inventory != null ? inventory.availableStock() : 0);
            return false;
        }
 
        // Step 2: 扣减库存
        String updateSql = """
            UPDATE t_inventory
            SET available_stock = available_stock - ?,
                reserved_stock = reserved_stock + ?,
                updated_at = NOW()
            WHERE product_id = ?
            """;
 
        int updated = jdbcTemplate.update(updateSql, quantity, quantity, productId);
 
        if (updated == 0) {
            throw new ConcurrentModificationException("库存扣减失败,可能被并发修改");
        }
 
        // Step 3: 记录库存流水(用于对账和审计)
        String logSql = """
            INSERT INTO t_inventory_log (product_id, change_qty, type, created_at)
            VALUES (?, ?, 'DEDUCT', NOW())
            """;
        jdbcTemplate.update(logSql, productId, -quantity);
 
        log.info("悲观锁库存扣减成功, productId={}, quantity={}, remaining={}",
            productId, quantity, inventory.availableStock() - quantity);
        return true;
    }
 
    // 批量扣减:按固定顺序获取锁,避免死锁
    @Transactional(isolation = Isolation.REPEATABLE_READ)
    public boolean batchDeduct(List<OrderItem> items) {
        // 关键:按 productId 排序后加锁,确保所有事务都以相同顺序获取锁,避免死锁
        List<Long> sortedProductIds = items.stream()
            .map(OrderItem::getProductId)
            .sorted()  // 固定顺序!这是避免死锁的核心策略
            .distinct()
            .toList();
 
        // 先按顺序锁定所有需要的库存记录
        for (Long productId : sortedProductIds) {
            String lockSql = "SELECT id FROM t_inventory WHERE product_id = ? FOR UPDATE";
            jdbcTemplate.queryForObject(lockSql, Long.class, productId);
        }
 
        // 再执行扣减
        for (OrderItem item : items) {
            boolean success = deductInventoryInternal(item.getProductId(), item.getQuantity());
            if (!success) {
                throw new InsufficientInventoryException("商品库存不足: " + item.getProductId());
            }
        }
        return true;
    }
}
 
// Record 定义
public record Inventory(Long id, Integer availableStock, Integer reservedStock, Long version) {}
public record OrderItem(Long productId, Integer quantity) {}

悲观锁的关键点:

  • FOR UPDATE 必须在事务内使用,事务提交或回滚时自动释放锁
  • 锁等待超时由 innodb_lock_wait_timeout 控制(默认 50 秒)
  • 死锁预防:多行更新时始终按相同顺序获取锁(如按主键排序)
  • 索引必须命中,否则会升级为表锁(或间隙锁范围过大)

3.2 乐观锁库存扣减(Optimistic Locking)

适用场景:读多写少、冲突概率较低的场景。不加锁,通过版本号检测并发冲突。

@Service
@RequiredArgsConstructor
public class OptimisticInventoryService {
 
    private final JdbcTemplate jdbcTemplate;
 
    /**
     * 乐观锁扣减库存(带重试)
     * 适用场景:普通电商下单、库存预占等冲突不那么极端的场景
     * 核心:CAS 思想,UPDATE 时检查 version,如果不匹配说明被其他事务修改过
     */
    public boolean deductInventoryWithRetry(Long productId, Integer quantity, int maxRetries) {
        for (int attempt = 0; attempt < maxRetries; attempt++) {
            // Step 1: 读取当前库存和版本号(不加锁)
            String selectSql = """
                SELECT id, available_stock, version
                FROM t_inventory
                WHERE product_id = ?
                """;
 
            InventoryVersion inventory = jdbcTemplate.queryForObject(selectSql,
                (rs, rowNum) -> new InventoryVersion(
                    rs.getLong("id"),
                    rs.getInt("available_stock"),
                    rs.getLong("version")
                ),
                productId
            );
 
            if (inventory == null || inventory.availableStock() < quantity) {
                return false;
            }
 
            // Step 2: 尝试更新,带上版本号条件
            // 这本质上是一个 CAS 操作:Compare And Swap
            String updateSql = """
                UPDATE t_inventory
                SET available_stock = available_stock - ?,
                    version = version + 1,
                    updated_at = NOW()
                WHERE product_id = ? AND version = ?
                """;
 
            int updated = jdbcTemplate.update(updateSql,
                quantity, productId, inventory.version());
 
            if (updated == 1) {
                log.info("乐观锁库存扣减成功, productId={}, quantity={}, attempt={}",
                    productId, quantity, attempt + 1);
                return true;
            }
 
            // updated == 0 表示 version 不匹配,被其他事务修改了
            log.warn("乐观锁冲突, productId={}, attempt={}/{}, 准备重试",
                productId, attempt + 1, maxRetries);
 
            // 指数退避,避免活锁(Livelock)
            if (attempt < maxRetries - 1) {
                try {
                    Thread.sleep((long) (Math.random() * 10 * (attempt + 1)));
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    throw new RuntimeException("重试被中断", e);
                }
            }
        }
 
        log.error("乐观锁扣减失败,超过最大重试次数, productId={}, maxRetries={}",
            productId, maxRetries);
        return false;
    }
 
    /**
     * 乐观锁批量扣减
     * 注意:批量场景下乐观锁的重试成本很高,需要谨慎使用
     */
    @Transactional
    public boolean batchDeductOptimistic(List<OrderItem> items) {
        // 乐观锁批量操作的问题:任何一个 item 冲突都可能导致全部重试
        // 策略:拆分为独立事务,或降级为悲观锁
        for (OrderItem item : items) {
            boolean success = deductInventoryWithRetry(
                item.getProductId(), item.getQuantity(), 3);
            if (!success) {
                throw new InsufficientInventoryException(
                    "库存扣减失败: " + item.getProductId());
            }
        }
        return true;
    }
}
 
public record InventoryVersion(Long id, Integer availableStock, Long version) {}

3.3 风控场景:资金冻结与释放(结合事务与锁)

@Service
@RequiredArgsConstructor
public class RiskFundFreezeService {
 
    private final JdbcTemplate jdbcTemplate;
 
    /**
     * 风控资金冻结
     * 场景:检测到可疑交易时,临时冻结用户部分资金,等待人工审核
     * 要求:强一致性,绝对不允许超冻(冻结金额 > 可用余额)
     */
    @Transactional(isolation = Isolation.REPEATABLE_READ, timeout = 5)
    public FreezeResult freezeFunds(Long userId, BigDecimal freezeAmount, String riskEventId) {
        // 1. 加锁读取用户资金账户(使用 FOR UPDATE 保证强一致性)
        String selectSql = """
            SELECT user_id, available_balance, frozen_balance, total_balance, version
            FROM t_user_fund
            WHERE user_id = ?
            FOR UPDATE
            """;
 
        UserFund fund = jdbcTemplate.queryForObject(selectSql,
            (rs, rowNum) -> new UserFund(
                rs.getLong("user_id"),
                rs.getBigDecimal("available_balance"),
                rs.getBigDecimal("frozen_balance"),
                rs.getBigDecimal("total_balance"),
                rs.getLong("version")
            ),
            userId
        );
 
        if (fund == null) {
            throw new UserNotFoundException("用户资金账户不存在: " + userId);
        }
 
        // 2. 风控校验:检查可用余额是否充足
        if (fund.availableBalance().compareTo(freezeAmount) < 0) {
            log.warn("资金冻结失败,余额不足, userId={}, required={}, available={}",
                userId, freezeAmount, fund.availableBalance());
            return FreezeResult.rejected("可用余额不足");
        }
 
        // 3. 执行冻结:可用余额减少,冻结余额增加,总额不变
        String updateSql = """
            UPDATE t_user_fund
            SET available_balance = available_balance - ?,
                frozen_balance = frozen_balance + ?,
                version = version + 1,
                updated_at = NOW()
            WHERE user_id = ? AND version = ?
            """;
 
        // 这里同时使用悲观锁(FOR UPDATE) + 乐观锁(version)
        // 双重保险:FOR UPDATE 防止并发事务同时读取,version 防止事务内的幻读/不可重复读
        int updated = jdbcTemplate.update(updateSql,
            freezeAmount, freezeAmount, userId, fund.version());
 
        if (updated == 0) {
            throw new ConcurrentModificationException("资金账户并发修改");
        }
 
        // 4. 记录冻结流水(幂等设计:riskEventId 作为唯一键)
        String insertLogSql = """
            INSERT INTO t_freeze_log (risk_event_id, user_id, freeze_amount, status, created_at)
            VALUES (?, ?, ?, 'FROZEN', NOW())
            ON DUPLICATE KEY UPDATE status = 'FROZEN', updated_at = NOW()
            """;
 
        jdbcTemplate.update(insertLogSql, riskEventId, userId, freezeAmount);
 
        // 5. 记录风控决策日志
        log.info("资金冻结成功, userId={}, freezeAmount={}, riskEventId={}",
            userId, freezeAmount, riskEventId);
 
        return FreezeResult.success(freezeAmount, fund.availableBalance().subtract(freezeAmount));
    }
 
    /**
     * 资金解冻(异步补偿链路)
     * 场景:风控审核通过后释放冻结资金,或审核拒绝后原路退回
     */
    @Transactional(isolation = Isolation.REPEATABLE_READ, timeout = 5)
    public boolean unfreezeFunds(String riskEventId, Long userId) {
        // 1. 校验冻结记录存在且状态正确
        String checkSql = "SELECT freeze_amount, status FROM t_freeze_log WHERE risk_event_id = ?";
        FreezeLog log = jdbcTemplate.queryForObject(checkSql,
            (rs, rowNum) -> new FreezeLog(
                rs.getBigDecimal("freeze_amount"),
                rs.getString("status")
            ),
            riskEventId
        );
 
        if (log == null || !"FROZEN".equals(log.status())) {
            log.warn("解冻失败,冻结记录不存在或状态错误, riskEventId={}", riskEventId);
            return false;
        }
 
        // 2. 加锁更新资金账户
        String updateFundSql = """
            UPDATE t_user_fund
            SET available_balance = available_balance + ?,
                frozen_balance = frozen_balance - ?,
                version = version + 1,
                updated_at = NOW()
            WHERE user_id = ? AND frozen_balance >= ?
            """;
 
        int updated = jdbcTemplate.update(updateFundSql,
            log.freezeAmount(), log.freezeAmount(), userId, log.freezeAmount());
 
        if (updated == 0) {
            throw new IllegalStateException("解冻失败,冻结余额不足或账户不存在");
        }
 
        // 3. 更新冻结记录状态(幂等)
        String updateLogSql = """
            UPDATE t_freeze_log
            SET status = 'RELEASED', released_at = NOW()
            WHERE risk_event_id = ? AND status = 'FROZEN'
            """;
 
        jdbcTemplate.update(updateLogSql, riskEventId);
        return true;
    }
}
 
// Record 定义
public record UserFund(Long userId, BigDecimal availableBalance,
                       BigDecimal frozenBalance, BigDecimal totalBalance, Long version) {}
public record FreezeLog(BigDecimal freezeAmount, String status) {}
public record FreezeResult(boolean success, String message,
                           BigDecimal frozenAmount, BigDecimal remainingAvailable) {
    public static FreezeResult success(BigDecimal frozen, BigDecimal remaining) {
        return new FreezeResult(true, "SUCCESS", frozen, remaining);
    }
    public static FreezeResult rejected(String reason) {
        return new FreezeResult(false, reason, BigDecimal.ZERO, BigDecimal.ZERO);
    }
}

4. 业界怎么做?

4.1 阿里巴巴/淘宝:双十一库存扣减的演进

背景:双十一零点秒杀场景,同一商品(如 iPhone)可能被数百万用户同时抢购,数据库行锁竞争极其激烈。

问题:早期使用纯数据库悲观锁(SELECT ... FOR UPDATE),热点行(同一商品库存行)成为瓶颈,大量连接等待锁,数据库线程池被打满,TPS 极低。

演进方案:

  1. 热点库存拆分:将一个商品的库存拆分为多行(如 stock_0 到 stock_99),用户按 user_id % 100 分散到不同行扣减。将单行热点转化为多行并行,降低锁竞争粒度。

  2. 乐观锁 + 异步补偿:预扣减阶段使用 Redis 做乐观预扣(Lua 脚本原子扣减),下单成功后异步同步到 MySQL。MySQL 层面使用乐观锁处理异步同步的冲突。

  3. 排队削峰:在应用层引入消息队列(RocketMQ),将秒杀请求排队,异步串行化处理数据库更新,将数据库压力从 "并发竞争" 转为 "顺序消费"。

  4. 阿里内部实践:淘宝在双十一下单系统中大量使用 MySQL 乐观锁 + 应用层限流 + 缓存预热 的组合。对于必须走数据库的强一致性操作(如资金),则通过 Shard 拆分 + 排队 降低单行竞争。

经验:阿里总结的核心经验是 —— "热点不可消除,只能转移"。要么转移到缓存(Redis),要么转移到消息队列(顺序处理),要么转移到应用层(令牌桶限流)。

4.2 美团:订单系统死锁排查与事务拆分

背景:美团外卖订单系统早期经常出现数据库死锁告警,尤其在午间高峰时段,show engine innodb status 频繁报告死锁回滚。

根因分析:

  • 订单创建事务中同时操作了 t_order(主单)、t_order_item(子单)、t_coupon(优惠券核销)、t_payment(支付流水)四张表
  • 不同事务中这四张表的更新顺序不一致:事务 A 先更新 t_order 再更新 t_coupon,事务 B 先更新 t_coupon 再更新 t_order
  • 高并发下极易形成循环等待

解决方案:

  1. 统一加锁顺序:美团制定了全团队的 "加锁顺序规范" —— 所有事务必须按照 t_order → t_order_item → t_payment → t_coupon 的顺序获取锁,彻底消除循环等待的可能。

  2. 事务拆分(Saga 模式):将大事务拆分为多个独立小事务:

    • 事务1:创建主单(核心,必须成功)
    • 事务2:创建子单(异步,失败可补偿)
    • 事务3:核销优惠券(异步,失败可回退)
    • 事务4:创建支付流水(异步,由支付回调驱动)
  3. 死锁监控与自愈:

    • 在数据库层部署死锁自动发现,通过 information_schema.innodb_lock_waits 实时监控
    • 应用层对死锁异常(SQLException with ErrorCode 1213)进行自动重试,重试策略为指数退避

美团总结:"大事务是死锁的温床。事务越小,持有锁的时间越短,死锁概率越低。能异步的不要同步,能拆分的不要合并。"

4.3 Shopify:电商库存系统的乐观锁实践

背景:Shopify 是全球领先的电商平台,支撑数百万商家。其库存系统面临多仓库、多渠道(线上、线下、第三方平台)同时扣减库存的挑战。

方案:Shopify 的核心库存表使用 乐观锁(version 字段) 进行并发控制,原因如下:

  • 库存读取频率远高于写入(浏览商品 >> 下单)
  • 冲突概率相对较低(不同商品、不同仓库天然分散)
  • 乐观锁无需数据库锁等待,读操作性能更好

优化细节:

  • 使用 PostgreSQL 的 FOR UPDATE SKIP LOCKED(类似 MySQL 不支持,但可用其他方式模拟)在需要悲观锁的场景下跳过已锁定的行,避免阻塞
  • 引入 事件溯源(Event Sourcing) 模式,库存变动以事件流形式存储,通过回放事件计算最终状态,天然支持 MVCC 思想

5. 业务场景怎么对照?

5.1 风控/Risk 场景的锁与事务策略

风控场景一致性要求推荐方案原因
实时交易拦截(同步决策)强一致悲观锁 (FOR UPDATE) + 短事务必须在 < 50ms 内完成,不允许重试,必须一次成功
风控额度扣减强一致悲观锁 + 版本号双重校验资金类操作,绝对不允许超扣
风险评分更新最终一致乐观锁 + 异步补偿评分可容忍短暂不一致,高并发下乐观锁性能更好
黑名单/白名单维护最终一致乐观锁 + 缓存同步读多写少,缓存层承担主要读取压力
批量风控规则计算读已提交即可RC 隔离级别 + 快照读不需要可重复读,减少间隙锁开销
事后审计对账读已提交即可RC 隔离级别只读操作,读取最新已提交数据即可

5.2 常见误区 vs 正确做法

误区正确做法
❌ "RR 隔离级别下完全没有幻读"✅ RR 下 快照读 无幻读,但 当前读(FOR UPDATE)仍可能幻读,需要 Next-Key Lock 配合才能避免
❌ "所有并发扣减场景都用悲观锁"✅ 读多写少用 乐观锁,极高并发冲突用 悲观锁 + 排队/拆分,没有银弹
❌ "加了 FOR UPDATE 就绝对安全"✅ FOR UPDATE 必须命中索引,否则退化为 表锁 或 间隙锁范围过大,性能灾难
❌ "事务越大越好,减少连接数"✅ 大事务是死锁和性能问题的根源,应该 尽早提交、拆分事务
❌ "RC 比 RR 性能好,所以都用 RC"✅ 大型加密货币交易所 等金融系统对一致性要求极高,RR 是更稳妥的选择;RC 适合读多写少的分析型场景
❌ "乐观锁不需要处理失败"✅ 乐观锁必须配合 重试机制 和 退避策略,否则高并发下大量失败反而降低性能

5.3 选型建议

When to use 悲观锁:

  • 金融交易、资金操作、库存扣减等强一致性场景
  • 冲突概率高(> 10% 的请求会竞争同一行)
  • 操作必须一次成功,不允许重试(或重试成本极高)

When to use 乐观锁:

  • 读多写少(读:写 > 10:1)
  • 冲突概率低(< 5%)
  • 可接受重试,且重试成本可控
  • 分布式环境下跨服务调用(避免长事务持有数据库连接)

When to use MVCC 快照读:

  • 纯读取操作(报表、查询、对账)
  • 不需要看到其他未提交事务的修改
  • 需要避免锁等待(如 大型加密货币交易所 的实时风控查询,不能因锁等待而超时)

6. 高频问题怎么答?

Q1: RR 隔离级别下真的完全解决了幻读吗?

简要答案:不完全。RR 下普通 SELECT(快照读)通过 MVCC 的 Read View 完全解决了幻读;但当前读(SELECT ... FOR UPDATE / UPDATE / DELETE)仍可能遇到幻读,需要通过 Next-Key Lock 来解决。

深入解释:

  • 场景:事务 A 执行 SELECT * FROM t WHERE id > 5 FOR UPDATE,此时读到 id=10。事务 B 插入 id=8 并提交。事务 A 再次执行相同 FOR UPDATE 查询,会读到 id=8(幻读)。
  • 但如果 id 列有索引,InnoDB 会对 (5, +∞) 范围内的记录和间隙加 Next-Key Lock,事务 B 的 INSERT 会被阻塞,从而避免幻读。
  • 例外:如果查询条件没有索引,或者使用 INSERT ... ON DUPLICATE KEY UPDATE 等特殊情况,仍可能出现幻读或锁范围异常。

面试技巧:回答时主动区分"快照读"和"当前读",展示深度。

Q2: MVCC 中的 Read View 在 RC 和 RR 下有什么区别?这是幻读和不可重复读差异的根本原因吗?

简要答案:是的,这是根本原因。

  • RC:每条 SELECT 语句执行时都生成新的 Read View。因此两次 SELECT 之间,如果有其他事务提交,新 Read View 能看到这些已提交的数据,导致不可重复读和幻读(快照读层面)。
  • RR:事务中的第一条 SELECT 执行时生成一个 Read View,整个事务期间所有快照读都复用这个 Read View。因此外界提交的数据对本事务不可见,避免了不可重复读和幻读(快照读层面)。

Q3: 死锁的四个必要条件,实际生产环境中如何快速排查和解决?

简要答案:

四个必要条件:互斥、占有且等待、不可抢占、循环等待。

排查步骤:

  1. SHOW ENGINE INNODB STATUS; 查看 LATEST DETECTED DEADLOCK
  2. 分析死锁日志,确定涉及的事务、SQL、加锁的索引和记录
  3. 使用 performance_schema.data_locks(MySQL 8.0+)查看当前锁等待链

解决策略:

  • 治标:应用层捕获 SQLException(Error Code 1213)自动重试
  • 治本:
    • 统一加锁顺序(如所有事务按主键升序获取锁)
    • 缩短事务(减少锁持有时间)
    • 将大事务拆分为小事务
    • 检查索引,确保查询命中索引避免锁升级

Q4: SELECT ... FOR UPDATE 什么时候会锁全表?如何避免?

简要答案:当查询条件没有命中索引时,InnoDB 无法进行行锁,会退化为对全表所有记录加锁(或锁住极大的间隙范围)。

避免方法:

  • 确保 WHERE 条件的列上有合适的索引
  • 使用 EXPLAIN 检查执行计划,确认 type 为 range、ref 或 eq_ref,避免 ALL(全表扫描)
  • 对于不确定是否走索引的查询,先用 EXPLAIN 验证
  • 考虑使用覆盖索引(Covering Index)减少回表

Q5: 乐观锁的 ABA 问题在库存扣减中会出现吗?如何解决?

简要答案:纯版本号的乐观锁不会出现 ABA 问题,因为每次更新版本号都会 +1,即使库存值从 100→80→100(A→B→A),版本号已经从 1→2→3,第二次更新时版本号 1 已经不匹配。

但如果使用 CAS 比较的是业务值而非版本号(如 UPDATE t SET stock = 100 WHERE stock = 80),则可能出现 ABA。解决方法是始终使用独立的 version 字段或 时间戳字段作为校验条件,而不是业务值。

Q6: undo log 和 redo log 的区别是什么?它们如何配合保证 ACID?

简要答案:

特性redo logundo log
作用保证 持久性(D)保证 原子性(A) 和 隔离性(I)
内容记录的是 "做了什么修改"(物理日志,页的修改)记录的是 "修改前的样子"(逻辑日志,反向操作)
写入时机事务执行过程中先写 redo log buffer,事务提交时刷盘事务执行过程中写入,无需立即刷盘
崩溃恢复用 redo log 重做已提交但未刷盘的事务用 undo log 回滚未提交的事务
清理时机循环利用(Checkpoint 机制),不需要长期保留当没有事务需要读取旧版本时(比所有活跃事务 min_trx_id 小),由 Purge 线程清理

配合流程:

  1. 事务修改数据页前,先写 undo log(记录旧值)
  2. 修改内存中的数据页(Buffer Pool)
  3. 写 redo log buffer(记录页的物理修改)
  4. 事务提交时,write-ahead logging 原则确保 redo log 先刷盘,数据页后刷盘
  5. 如果事务回滚,利用 undo log 恢复旧值
  6. 如果崩溃后恢复,利用 redo log 重做已提交事务,利用 undo log 回滚未提交事务

类比:redo log 就像记账本的"修改记录",即使账本丢了也能根据记录重抄;undo log 就像"修改前的复印件",写错了可以对照复印件改回来。

Q7: 在 大型加密货币交易所 这种全球化交易所中,跨地域部署下事务隔离级别应该如何选择?

简要答案:

  • 核心业务(交易撮合、资金划转):必须使用 RR + 悲观锁,因为资金安全和数据一致性是第一优先级,性能退居其次。
  • 分析型业务(风控报表、用户行为分析):可使用 RC,因为只需要读取已提交的数据,不需要可重复读,且 RC 下间隙锁更少,并发性能更好。
  • 只读副本(Read Replica):用于报表和查询,天然使用快照读(MVCC),不承担写入压力。
  • 全球化部署的特殊考虑:跨地域主从同步存在延迟,从库读取可能读到旧数据(主从延迟)。风控系统应优先读取主库或等待从库同步延迟满足阈值后再读取。

7. 还要关联学什么?

  • C1 - MySQL 索引原理:理解索引结构是正确使用锁的前提,FOR UPDATE 必须命中索引
  • B3 - 分布式锁:单库悲观锁无法解决跨服务并发,需要 Redis/ZK 分布式锁
  • B2 - 分布式事务:大事务拆分后需要 Saga/TCC 保证最终一致性
  • E2 - 实时风控系统:风控系统的同步决策链路对事务延迟极其敏感
  • A1 - JMM 与 synchronized:Java 内存模型与数据库事务隔离在并发控制思想上有相通之处