事务
第一周:MySQL 事务 + 锁 + 分布式事务
目标:从"没用过事务"变成"能把事务讲清楚,并结合项目说出风险和方案"
目录
一、事务基础 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可靠性)

浙公网安备 33010602011771号