事务

第一周:MySQL 事务 + 锁 + 分布式事务

目标:从"没用过事务"变成"能把事务讲清楚,并结合项目说出风险和方案"


目录

  1. 事务基础 ACID
  2. 隔离级别与并发问题
  3. MVCC 原理
  4. @Transactional 详解
  5. MySQL 锁机制
  6. 分布式事务
  7. 面试题汇总

一、事务基础 ACID

事务解决的核心问题:一组操作要么全成功,要么全失败,不能出现中间状态。

项目中的真实案例

// saveMarkBookRelation 中没有事务保护
markBookRelationMapper.deleteMarkNamesRelation(bookId);  // 删除成功
markBookRelationMapper.batchSave(saveList);              // 执行到一半宕机

// 结果:旧数据删了,新数据只存了一半,标记关系永久损坏

四个特性

特性 全称 防的是什么 底层实现
A 原子性 Atomicity 操作做了一半出现中间状态 undo log(记录反向操作,失败时回滚)
C 一致性 Consistency 数据违反业务约束 AID 共同保证的目标
I 隔离性 Isolation 多事务并发互相干扰 锁 + MVCC
D 持久性 Durability 提交后数据丢失 redo log(WAL,先写日志再写磁盘)

记忆关键:A 靠 undo log,D 靠 redo log,I 靠锁+MVCC,C 是最终目标。


二、隔离级别与并发问题

不隔离会出现的三个问题

脏读

事务A 修改了一行数据但还没提交
事务B 读到了事务A 未提交的数据
事务A 随后回滚
→ 事务B 读到的是根本不存在的数据

不可重复读

事务A 第一次读:price = 9.9
事务B 修改并提交:price = 19.9
事务A 第二次读:price = 19.9
→ 同一事务,同一SQL,两次结果不同

幻读

事务A 查询上架书籍数量:100 条
事务B 新增一条上架书籍并提交
事务A 再次查询:101 条
→ 同一事务,同一条件,行数不同,多出来的像幻觉

四个隔离级别

隔离级别 脏读 不可重复读 幻读 说明
READ UNCOMMITTED ✗ ✗ ✗ 什么都不隔离
READ COMMITTED ✓ ✗ ✗ Oracle 默认
REPEATABLE READ ✓ ✓ ✗ MySQL 默认
SERIALIZABLE ✓ ✓ ✓ 完全串行,性能极差

你们项目:使用 MySQL 默认的 REPEATABLE READ。
MySQL 的 RR 通过间隙锁在很大程度上解决了幻读,但不是 100%。


三、MVCC 原理

核心思想

不用加锁,而是给每行数据保存多个历史版本,不同事务看到不同版本。

每行数据的两个隐藏字段

trx_id    → 最后一次修改这行的事务ID
roll_ptr  → 指向 undo log 的指针(上一个版本在哪)

undo log 版本链

当前版本: price=19.9, trx_id=200
    ↓ roll_ptr
历史版本: price=9.9,  trx_id=100
    ↓ roll_ptr
历史版本: price=5.9,  trx_id=50

ReadView(快照)

事务开始时生成,记录"此刻哪些事务还没提交"。

ReadView 包含:
  m_ids          → 当前活跃(未提交)的事务ID列表
  min_trx_id     → 活跃事务中最小的ID
  max_trx_id     → 下一个要分配的事务ID
  creator_trx_id → 创建本 ReadView 的事务ID

可见性判断规则

读一行数据时,沿版本链找,找到第一个满足以下条件的版本:

① trx_id == creator_trx_id  → 自己修改的,可见
② trx_id < min_trx_id       → 在我开始前已提交,可见
③ trx_id >= max_trx_id      → 在我开始后才开启,不可见
④ trx_id 在 m_ids 中         → 开始时还未提交,不可见 → 沿版本链找上一个版本

RC 和 RR 的本质区别

READ COMMITTED:  每次 SELECT 都生成新的 ReadView
                 → 能读到别的事务最新提交 → 不可重复读

REPEATABLE READ: 只在事务第一次 SELECT 时生成 ReadView,之后复用
                 → 整个事务期间视图固定 → 可重复读

结合你的项目

你们有读写分离,MySQL 变更后通过 RocketMQ 延时消息 10s 后刷新 Redis。

事务隔离 vs 读写分离延迟是两个维度:
  事务隔离:解决同一 MySQL 实例内,并发事务之间的可见性
  读写分离延迟:解决主从之间的数据同步延迟

延时 10s 本质上是在等主从同步完成,再让业务读到最新数据。

四、@Transactional 详解

底层原理

Spring 事务本质是 AOP 动态代理:

// Spring 实际执行的伪代码
try {
    connection.setAutoCommit(false);   // 开启事务
    target.yourMethod();               // 执行业务代码
    connection.commit();               // 提交
} catch (RuntimeException e) {
    connection.rollback();             // 回滚
}

传播机制(掌握3个)

// 最常用,默认值:有事务就加入,没有就新建
@Transactional(propagation = Propagation.REQUIRED)

// 无论外部有没有事务,自己都新建一个独立事务
// 典型场景:记录操作日志(主业务回滚,日志不回滚)
@Transactional(propagation = Propagation.REQUIRES_NEW)

// 不支持事务,有事务就挂起
@Transactional(propagation = Propagation.NOT_SUPPORTED)

结合你的项目:

@Transactional  // REQUIRED:加入外层事务
public int updateBookInfo(Map map, String bookId) {
    bookMapper.updateMap(...);
    saveMarkBookRelation(bookId, markNames);  // 同一事务
}

@Transactional  // REQUIRED:默认加入 updateBookInfo 的事务
public boolean saveMarkBookRelation(...) {
    markBookRelationMapper.deleteMarkNamesRelation(bookId);
    return markBookRelationMapper.batchSave(saveList) > 0;
    // updateBookInfo 失败 → 这里也回滚 ✓
}

失效的 8 种场景

记忆方法:从代理机制推导,分三类。

代理相关(3个)

① 非 public 方法

@Transactional
private void saveData() { ... }  // ❌ 代理无法重写 private 方法

② 同类内部调用(最常见、最坑)

@Service
public class AdminBookService {
    public void methodA() {
        this.methodB();  // ❌ this 是原始对象,不是代理对象,事务失效
    }

    @Transactional
    public void methodB() { ... }
}
你们项目的隐患:
  AdminBookService.updateBookInfo 会递归调用 this.updateBookInfo()
  如果加了 @Transactional,内层递归调用的事务会失效!

解决方案:
  ① 注入自身:@Autowired AdminBookService self; → self.methodB()
  ② 抽到另一个 Bean
  ③ AopContext.currentProxy() 获取当前代理对象

③ Bean 未被 Spring 管理

// 缺少 @Service / @Component,Spring 没有创建代理
public class BookService {
    @Transactional
    public void saveData() { ... }  // ❌ 没有代理,事务失效
}

异常相关(2个)

④ 异常被 catch 吃掉

@Transactional
public boolean saveMarkBookRelation(...) {
    markBookRelationMapper.deleteMarkNamesRelation(bookId);
    try {
        return markBookRelationMapper.batchSave(saveList) > 0;
    } catch (Exception e) {
        log.error("保存失败", e);
        return false;  // ❌ 吃掉异常,Spring 不知道出错,照常提交!
        // delete 执行了,但不会回滚!
    }
}

⑤ 非运行时异常未配置 rollbackFor

@Transactional  // ❌ 默认只回滚 RuntimeException 和 Error
public void saveData() throws Exception {
    mapper.insert(data);
    throw new Exception("出错了");  // 受检异常,不触发回滚!
}

// 正确写法
@Transactional(rollbackFor = Exception.class)  // ✓

配置相关(3个)

⑥ 传播机制为 NOT_SUPPORTED

@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void saveData() {
    mapper.insert(data);  // ❌ 主动声明不支持事务
}

⑦ 数据库引擎不支持事务

CREATE TABLE xxx ENGINE=MyISAM;  -- MyISAM 不支持事务,@Transactional 加了也没用
-- InnoDB 才支持事务

⑧ 多数据源未指定事务管理器

// 你们项目有多数据源(dataSource_contentself)
@Transactional  // ❌ 默认用主库事务管理器,操作从库数据源时事务不生效

// 正确写法
@Transactional(transactionManager = "contendselfTransactionManager")  // ✓

汇总

代理相关(3):非public、同类内调用、Bean未被管理
异常相关(2):异常被catch、非运行时异常未配rollbackFor
配置相关(3):NOT_SUPPORTED传播、MyISAM引擎、多数据源未指定管理器

五、MySQL 锁机制

锁的分类

按粒度:
  表锁   → 锁整张表,并发低,MyISAM 用
  行锁   → 锁具体行,并发高,InnoDB 用

按模式:
  共享锁 S锁(读锁)→ SELECT ... LOCK IN SHARE MODE
  排他锁 X锁(写锁)→ INSERT / UPDATE / DELETE / SELECT ... FOR UPDATE

行锁的三种形式

Record Lock(记录锁)

锁住索引上的某一条记录。

SELECT * FROM book WHERE book_id = '4001' FOR UPDATE;
-- 只锁 book_id='4001' 这一行,其他行不受影响

Gap Lock(间隙锁)

锁住两个索引值之间的间隙,防止插入新行(解决幻读)。

表中 price 索引值:5, 10, 20, 30

Gap Lock (10, 20):锁住 price 在 10 到 20 之间的间隙
→ 其他事务无法插入 price = 15 的新行
→ 注意:间隙锁只在 REPEATABLE READ 级别存在

Next-Key Lock(临键锁)= Record Lock + Gap Lock

InnoDB 行锁默认使用 Next-Key Lock,是一个左开右闭区间 (a, b]。

表中 price 索引值:5, 10, 20, 30

形成的 Next-Key Lock 区间:
  (-∞, 5]
  (5,  10]
  (10, 20]
  (20, 30]
  (30, +∞)

退化规则(核心)

Next-Key Lock 在两种情况下退化,退化 = 锁范围缩小:

退化规则1:唯一索引 + 等值查询 + 记录存在 → 退化为 Record Lock

SELECT * FROM book WHERE id = 5 FOR UPDATE;
-- id 是主键(唯一索引),记录存在
-- Next-Key Lock (1, 5] 退化为 Record Lock
-- 只锁 id=5 这一行,不锁间隙

退化规则2:等值查询向右遍历,最后一条不满足条件 → 退化为 Gap Lock

-- price 是普通索引,现有值:5, 10, 20
SELECT * FROM book WHERE price = 10 FOR UPDATE;

-- Step1: 找到 price=10,加 Next-Key Lock (5, 10]
-- Step2: 向右扫到 price=20,不满足条件,退化为 Gap Lock (10, 20)

-- 最终:Next-Key Lock (5, 10] + Gap Lock (10, 20)
-- 禁止插入 price ∈ (5, 20) 的新行

范围查询不退化:

SELECT * FROM book WHERE id >= 5 AND id < 15 FOR UPDATE;
-- 扫描到 id=5, 10, 20(20不满足但仍加锁)
-- 加锁:(1, 5] + (5, 10] + (10, 20]
-- 范围查询会扫描到第一个不满足条件的记录才停止

结合你的项目

// 你们高频操作:按主键更新书籍
bookMapper.updateMap(mainMap, extendMap, bookId);
// bookId 是主键 → 唯一索引等值查询 → 退化为 Record Lock
// 只锁这一行,不影响其他书籍并发更新 ✓

// 危险操作:按非唯一索引批量更新
UPDATE b_book SET status='下架' WHERE cp_partner_id=1000
// cp_partner_id 是普通索引 → Next-Key Lock 不退化
// 会锁住相邻 cp_partner_id 之间的间隙
// 其他事务插入同 cp_partner_id 的新书会被阻塞 → 容易引发死锁

死锁

经典死锁场景:

事务A:锁住 book_id='4001',等待 book_id='4002'
事务B:锁住 book_id='4002',等待 book_id='4001'
→ 互相等待,死锁

InnoDB 自动检测死锁,回滚代价小的那个事务。

预防死锁:

① 固定加锁顺序(所有事务按同一顺序加锁)
② 减少事务持有锁的时间(事务尽量短小)
③ 给查询条件字段加索引(无索引行锁升级为表锁,加剧冲突)
④ 使用 READ COMMITTED(无间隙锁,减少锁冲突)

六、分布式事务

为什么需要分布式事务

你们系统:CP平台审核通过 → 同步到内容中台

步骤1: cp_short_play 更新 syncLibStatus=SUCCESS  (CP平台的DB)
步骤2: b_book 插入新书记录                        (内容中台的DB)

两个数据库,普通事务管不了
步骤1成功 + 步骤2失败 → 数据不一致

方案一:Seata AT 模式

核心思想: 自动生成 undo log,失败时自动回滚,代码侵入小。

三个角色:

TC(Transaction Coordinator)→ 事务协调者,Seata Server(独立部署)
TM(Transaction Manager)    → 事务发起方,加 @GlobalTransactional 的服务
RM(Resource Manager)       → 各参与服务

执行流程:

第一阶段(执行):
  RM 执行 SQL 前,查询 beforeImage(数据前镜像)
  执行 SQL
  查询 afterImage(数据后镜像)
  生成 undo log 写入本地 DB
  提交本地事务(释放数据库锁)

第二阶段(提交/回滚):
  全部成功 → TC 通知各 RM 删除 undo log
  有失败   → TC 通知各 RM 读取 undo log 执行反向 SQL 回滚

代码示例:

@GlobalTransactional  // 只需加这一个注解
public void syncShortPlay(String cpBookId) {
    cpShortPlayMapper.updateSyncStatus(cpBookId, SUCCESS);  // CP平台DB
    adminBookRpc.saveBookInfo(bookVO);                       // 内容中台DB(Dubbo调用)
}

优缺点:

优点:
  侵入性低,只加 @GlobalTransactional
  自动生成/回滚 undo log,不需要手写补偿逻辑

缺点:
  需要额外部署 Seata Server,引入新的基础设施依赖
  第一阶段提交后到第二阶段之间存在脏读风险(需 @GlobalLock)
  有全局锁开销,高并发场景性能损耗明显
  适合短事务,不适合长事务

方案二:TCC 模式

核心思想: 业务自己实现三个方法,手动控制提交和回滚。

Try     → 预留资源(冻结、预占)
Confirm → 确认操作(真正执行)
Cancel  → 释放预留(回滚)

代码示例:

// Try:预检查,标记处理中
public boolean trySync(String bookId) {
    bookMapper.updateStatus(bookId, PROCESSING);
    return true;
}

// Confirm:真正写入数据
public boolean confirmSync(String bookId) {
    bookMapper.insertToMainLib(bookId);
    bookMapper.updateStatus(bookId, SUCCESS);
    return true;
}

// Cancel:回滚预留
public boolean cancelSync(String bookId) {
    bookMapper.updateStatus(bookId, WAIT);
    return true;
}

需要处理三个坑:

空回滚:Try 还没执行,Cancel 先到了
  解决:Cancel 时检查是否执行过 Try,没执行直接返回成功

幂等:Confirm/Cancel 可能被重复调用
  解决:每次操作前检查当前状态,已处理则直接返回

悬挂:Cancel 执行完,Try 才到达
  解决:Cancel 执行后记录标记,Try 到达时发现已取消直接放弃

适用场景:

高并发、对性能敏感的场景
例:秒杀库存预占、支付资金冻结
不适合:操作复杂、步骤多的场景(三个方法写起来很重)

方案三:本地消息表

核心思想: 利用本地事务绑定业务操作和消息写入,消费端保证幂等。

步骤1(同一本地事务):
  ① 执行业务操作(UPDATE book)
  ② 往本地消息表插入消息记录
  两步原子完成,要么全成功要么全失败

步骤2(定时任务扫描):
  扫描状态=待发送的消息 → 发送到 MQ → 更新状态=已发送

步骤3(消费端):
  消费消息 → 执行目标操作 → 幂等处理(防重复消费)

适用场景:

跨系统、允许最终一致的场景
对可靠性要求高(消息存本地DB,不依赖MQ可靠性)
需要灵活的重试策略

RocketMQ 事务消息 vs 本地消息表

两者解决同一个问题:保证"生产端本地事务"和"消息发送"的原子性。

对比项 RocketMQ 事务消息 本地消息表
消息存储 存在 Broker 存在本地 DB
MQ 故障 半消息可能丢失 消息安全,MQ 恢复后继续发
重试策略 受 MQ 参数限制(最多15次回查) 完全自定义
消费端失败 进死信队列,需人工处理 自定义重试和告警
与 MQ 耦合 强依赖 RocketMQ 特有 API MQ 只是传输工具,可替换
实现复杂度 中(需实现回查接口) 中(需维护消息表+定时任务)
适用场景 简单场景、强绑定 RocketMQ 复杂场景、高可靠要求

你们项目现状:

MySQL 更新 → 直接发 RocketMQ 延时消息(无本地消息表)

隐患:MySQL 更新成功,但发 MQ 失败 → Redis 永远是旧数据
你们能接受是因为业务允许短暂不一致

如果要改造:
  MySQL 更新 + 写消息表(同一事务)
  → 定时任务扫描消息表 → 发 MQ → 刷 Redis
  这样消息绝对不会丢

方案选型原则

强一致 + 短事务 + 少改代码   → Seata AT
高并发 + 性能敏感             → TCC
跨系统 + 允许最终一致         → 本地消息表
简单场景 + 强绑定 RocketMQ    → RocketMQ 事务消息
你们现有缓存刷新场景          → 延时消息(已够用)

七、面试题汇总

基础题

Q1:MySQL 默认隔离级别是什么?如何实现不可重复读?

MySQL 默认 REPEATABLE READ。通过 MVCC 实现:RR 级别下,事务第一次 SELECT 时生成 ReadView 并复用整个事务,后续查询通过 ReadView 的可见性规则过滤版本链,始终读到同一个快照,因此同一查询结果不变。

Q2:@Transactional 同类内部调用为什么失效?怎么解决?

Spring 事务基于 AOP 动态代理实现,同类内部调用使用 this 引用,绕过了代理对象,拦截器无法介入,事务失效。解决方案:① 注入自身 Bean 调用;② 抽到另一个 Bean;③ 通过 AopContext.currentProxy() 获取代理对象。

Q3:间隙锁的作用是什么?什么时候会退化?

间隙锁锁住索引间的间隙,防止其他事务插入新行,解决幻读问题,只在 RR 级别存在。退化场景:① 唯一索引等值查询且记录存在,退化为 Record Lock;② 等值查询向右遍历到第一个不满足条件的记录,该锁退化为 Gap Lock。

进阶题

Q4:Seata AT 和 TCC 分别适合什么场景?

AT 适合:操作简单、低频、对代码侵入敏感的场景,自动生成 undo log,只需加 @GlobalTransactional。TCC 适合:高并发、性能敏感的场景,手动实现 Try/Confirm/Cancel,无全局锁开销,但需处理空回滚、幂等、悬挂三个问题。

Q5:为什么不用 RocketMQ 事务消息,而用本地消息表?

RocketMQ 事务消息只保证生产端本地事务和消息发送的原子性,但:① 半消息存在 Broker,MQ 故障时消息可能丢失;② 重试策略受 MQ 参数限制,最多15次回查;③ 强依赖 RocketMQ 特有 API,与 MQ 耦合。本地消息表消息存在自己的 DB,可靠性更高,重试策略完全自定义,与 MQ 解耦。

Q6:结合你的项目,哪里有事务风险?如何修复?

saveMarkBookRelation 中 deleteMarkNamesRelation 和 batchSave 没有事务保护,若 batchSave 失败,旧数据已删除,新数据未完整写入,标记关系损坏。修复:给 saveMarkBookRelation 加 @Transactional(rollbackFor = Exception.class),确保两步操作原子完成。调用方 updateBookInfo 若也需要整体原子,需注意传播机制和内部调用失效问题。


八、知识图谱

MySQL 事务
├── ACID
│   ├── 原子性 → undo log
│   ├── 持久性 → redo log
│   └── 隔离性 → 锁 + MVCC
│
├── 隔离级别
│   ├── RC → 每次查询生成新 ReadView → 不可重复读
│   └── RR → 事务首次查询生成 ReadView 复用 → 可重复读(MySQL默认)
│
├── MVCC
│   ├── 版本链(trx_id + roll_ptr + undo log)
│   └── ReadView 可见性判断(4条规则)
│
├── @Transactional
│   ├── 底层:AOP 动态代理
│   ├── 传播机制(REQUIRED / REQUIRES_NEW / NOT_SUPPORTED)
│   └── 失效8场景
│       ├── 代理相关:非public、同类内调用、Bean未被管理
│       ├── 异常相关:异常被catch、非运行时异常
│       └── 配置相关:NOT_SUPPORTED、MyISAM、多数据源
│
├── 锁机制
│   ├── Record Lock(行锁)
│   ├── Gap Lock(间隙锁,防幻读)
│   ├── Next-Key Lock = Gap + Record(默认,左开右闭)
│   │   ├── 退化1:唯一索引等值 → Record Lock
│   │   └── 退化2:等值查询末尾 → Gap Lock
│   └── 死锁(固定加锁顺序预防)
│
└── 分布式事务
    ├── Seata AT(自动undo log,低侵入,有全局锁)
    ├── TCC(手动三方法,高性能,需处理空回滚/幂等/悬挂)
    ├── 本地消息表(最终一致,高可靠,与MQ解耦)
    └── RocketMQ事务消息(简单场景,依赖MQ可靠性)
posted @ 2026-03-20 17:57  zhangph  阅读(31)  评论(0)    收藏  举报