最近在追AG版的"凡人修仙传",太多乐子了。结果回看自己最近的学习,何尝不是另一种凡人修仙传?现在的一篇笔记的学习量感觉比这个系列1-8的学习量还要多了,纯癫掉了。
行锁与事务并发
你已经验证过"两条更新一起回滚",现在观察:两个事务同时修改同一名学生,会发生什么?
1. 修改数据时,InnoDB 会加锁
假设事务 A 正在修改某个学生,尚未提交。这时事务 B 也要修改同一条记录,就需要等待 A 释放锁。
对于这次实验的"主键等值查询、记录已存在",InnoDB 会锁住对应的索引记录。事务提交或完整回滚后,相关锁会释放。
这里的锁由 MySQL 的 InnoDB 管理 。Java 的 @Transactional 负责划定事务范围,执行 SQL 时数据库仍会按自己的规则加锁。
2. 准备两个独立的 MySQL 连接
打开两个 PowerShell 窗口,分别登录:
mysql -h localhost -P 3306 -u root -p
把它们叫作 窗口 A、窗口 B。两个窗口都执行:
USE student_demo;
在窗口 A 创建一张独立练习表,执行一次即可:
CREATE TABLE student_lock_demo (
id INT PRIMARY KEY,
score INT NOT NULL
) ENGINE=InnoDB;
INSERT INTO student_lock_demo (id, score) VALUES (1, 90);
3. 按顺序执行,观察等待
Q:START TRANSACTION又是什么意思?
A:START TRANSACTION; 表示开启事务
Q:什么叫不要提交,回车就代表提交吗?
A:你可以正常输入并按回车执行,看到 Query OK,说明 UPDATE 已经执行成功,但这个事务还没提交 。此时停在 mysql>,切换到窗口 B,继续实验。
先在 窗口 A 执行:
START TRANSACTION;
UPDATE student_lock_demo
SET score = 95
WHERE id = 1;
此时先停住,暂时不要提交。A 已经修改记录,并持有相应的锁。

接着在 窗口 B 执行:
START TRANSACTION;
UPDATE student_lock_demo
SET score = 80
WHERE id = 1;

B 的 UPDATE 预期会等待,暂时不会返回 mysql> 提示符。 因为它也需要修改 A 正锁住的那条记录。
可以看到这里没有mysql>。
此时切回 窗口 A 执行:
COMMIT;
A 提交并释放锁后,B 的 UPDATE 就能继续,随后显示执行结果。再在 窗口 B 执行:
COMMIT;
SELECT * FROM student_lock_demo;
最终成绩应该是 80。

如果等待太久,B 可能报告锁等待超时。此时先在 A 执行 ROLLBACK;,再在 B 执行 ROLLBACK;,结束两边事务后重新实验。锁等待超时默认可能只回滚当前语句,所以这里明确结束整个事务。

Q:为什么之前执行 UPDATE 就能直接保存?
因为 MySQL 连接默认通常开启自动提交 。没有显式开启事务时,一条 UPDATE 执行成功,数据库就会自动提交这一条。先执行 START TRANSACTION;,再执行 UPDATE则要等你执行 COMMIT;
你也可以撤销这次更新:
START TRANSACTION;
UPDATE student_lock_demo SET score=95 WHERE id=1;
ROLLBACKK;
这样 UPDATE 虽然执行过,但回滚后成绩会恢复为事务开始前的值。
4. 读已提交:每次普通查询读取新的快照
READ COMMITTED(读已提交)
在 窗口 A 设置本连接的隔离级别,并把成绩重置为 90:
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
START TRANSACTION;
UPDATE student_lock_demo SET score = 90 WHERE id = 1;
COMMIT;
接着按表格顺序操作:
| 顺序 | 窗口 | 执行 SQL | 预期 |
|---|---|---|---|
| ① | A | START TRANSACTION; |
开始事务 |
| ② | A | SELECT score FROM student_lock_demo WHERE id = 1; |
90 |
| ③ | B | START TRANSACTION; |
开始另一个事务 |
| ④ | B | UPDATE student_lock_demo SET score = 95 WHERE id = 1; |
暂时还没提交 |
| ⑤ | A | SELECT score FROM student_lock_demo WHERE id = 1; |
仍然是 90 |
| ⑥ | B | COMMIT; |
B 的 95 提交 |
| ⑦ | A | SELECT score FROM student_lock_demo WHERE id = 1; |
变成 95 |
| ⑧ | A | COMMIT; |
结束 A 的事务 |
A 读不到 B 尚未提交 的 95,所以叫"读已提交"。B 提交后,A 下一次普通查询就能看见它。
同一个事务里,A 先读到 90,后来读到 95,这种现象叫 不可重复读。
A窗口

B窗口

5. 可重复读:同一个事务里的普通查询复用快照
REPEATABLE READ(可重复读)
然后按下面顺序操作:
| 顺序 | 窗口 | 执行 SQL | 预期 |
|---|---|---|---|
| ① | A | START TRANSACTION; |
开始事务 |
| ② | A | SELECT score FROM student_lock_demo WHERE id = 1; |
90,建立此次一致性读取的快照 |
| ③ | B | START TRANSACTION; |
开始另一个事务 |
| ④ | B | UPDATE student_lock_demo SET score = 95 WHERE id = 1; |
修改成功 |
| ⑤ | B | COMMIT; |
B 提交 95 |
| ⑥ | A | SELECT score FROM student_lock_demo WHERE id = 1; |
仍然是 90 |
| ⑦ | A | COMMIT; |
结束 A 的事务 |
| ⑧ | A | SELECT score FROM student_lock_demo WHERE id = 1; |
95 |
A 的第二次查询复用同一个事务里的快照,因此仍看到 90。事务结束后再查询,就能看到已经提交的 95。
A窗口

B窗口

6. READ UNCOMMITTED:为什么会发生脏读
下面是在两个 MySQL 客户端里做的实验,沿用之前的 student_lock_demo 表。先在两个窗口中执行:
USE student_demo;
ROLLBACK;
先由窗口 B 把成绩恢复成 90:
START TRANSACTION;
UPDATE student_lock_demo SET score = 90 WHERE id = 1;
COMMIT;
然后按顺序操作。
窗口 A:设置为读未提交,再开启事务:
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
START TRANSACTION;
窗口 B:改为 99,暂时不提交:
START TRANSACTION;
UPDATE student_lock_demo SET score = 99 WHERE id = 1;
窗口 A 查询:
SELECT score FROM student_lock_demo WHERE id = 1;
此时能够读到:
99
窗口 B 撤销修改:
ROLLBACK;
窗口 A 再查:
SELECT score FROM student_lock_demo WHERE id = 1;
得到:
90
A 刚才读到的 99,是 B 最终没有提交的数据,这就是脏读。
最后窗口 A 结束事务:
COMMIT;
7. SERIALIZABLE:它怎么阻止冲突
"可串行化"不表示整个数据库只能运行一个事务。它要求:即使事务交错执行,最终效果也应当等价于某种串行执行顺序。
还是使用这条学生记录。先确保两个窗口的旧事务都已结束:
ROLLBACK;
窗口 A:
SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;
START TRANSACTION;
SELECT score FROM student_lock_demo WHERE id = 1;
保留 A 的事务,不要提交。
窗口 B:
START TRANSACTION;
UPDATE student_lock_demo
SET score = 80
WHERE id = 1;
在这个 InnoDB 显式事务实验中,B 的更新会等待。
原因是:A 在 SERIALIZABLE 隔离级别下的普通 SELECT,会对读取的记录加共享锁,B 更新需要的排他锁与之冲突。
回到窗口 A:
COMMIT;
B 才能继续完成更新,然后在 B 中:
COMMIT;
如果读取的是一个范围,InnoDB 还可能通过范围相关的锁,阻止其他事务插入会影响这个查询结果的记录。
代价也很直接:等待可能增加,还可能发生死锁,需要应用处理。
8. 理论知识
这为什么叫"隔离"?
A 和 B 同时操作同一张表,隔离级别规定它们何时看得到彼此的修改 。锁控制并发访问,多版本并发控制 MVCC 则让普通查询能够读取适合当前事务的历史版本。
所以在可重复读实验中,A 看到旧值 90 时,数据库当前已提交的成绩确实可以是 95。A 读的是它的快照,不会把数据库里的成绩改回 90。
三种问题:脏读、不可重复读、幻读
继续用学生成绩举例,A、B 表示两个同时进行的事务。
| 问题 | 发生过程 | 关键区别 |
|---|---|---|
| 脏读 | B 把小红成绩改成 95,还没提交;A 就读到了 95;随后 B 回滚 | 读到了别人尚未提交的数据 |
| 不可重复读 | A 读到小红 90;B 修改为 95 并提交;A 再读,变成 95 | 同一个事务内,同一条记录的内容变了 |
| 幻读 | A 查询所有成绩 ≥90 的学生,得到 2 人;B 新增一个 95 分学生并提交;A 再查,得到 3 人 | 同一个事务内,满足条件的记录集合变了 |
用两种查询区分后两者:
-- 关注同一条记录的内容
SELECT score FROM students WHERE name = '小红';
-- 关注满足条件的记录集合
SELECT name FROM students WHERE score >= 90;
不可重复读可以理解为"刚才这个人不是这个成绩",幻读可以理解为"刚才这份名单里没有这个人"。
它们都以同一个事务中多次读取为讨论前提。你结束事务后重新查询,看到别人刚提交的修改,是正常行为。
2. 四种隔离级别
先看数据库教材中常用的对应关系:
| 隔离级别 | 中文 | 脏读 | 不可重复读 | 幻读 |
|---|---|---|---|---|
| READ UNCOMMITTED,RU | 读未提交 | 可能 | 可能 | 可能 |
| READ COMMITTED,RC | 读已提交 | 避免 | 可能 | 可能 |
| REPEATABLE READ,RR | 可重复读 | 避免 | 避免 | 标准允许发生 |
| SERIALIZABLE | 可串行化 | 避免 | 避免 | 避免 |
这张表是隔离级别的一般定义。MySQL InnoDB 的 RR 对幻读还有额外处理,下面单独解释。
四个级别可以这样理解:
- **RU:**别人还没提交的修改,我也可能读到。
- **RC:**每次读取时,只看已经提交的数据。
- **RR:**在同一事务里,多次普通查询通常沿用同一个快照。
- **SERIALIZABLE:**保证并发事务的效果,等价于它们按照某个顺序依次执行。
隔离级别越严格,对并发执行的约束通常越多,但不能简单理解成"越高越适合所有项目"。
Q:如何查询当前连接的隔离级别?
SELECT @@SESSION.transaction_isolation;
MVCC
1. MVCC 是什么?
MVCC 全称是 Multi-Version Concurrency Control,多版本并发控制。
你可以先理解为:
同一条记录可以有历史版本,不同事务根据自己的可见性规则,读取适合自己的版本。
例如小红最初是 90 分,事务 B 把她改成 95 分并提交。
数据库里的当前记录已经是 95,但事务 A 如果需要读取之前的快照,仍然可能读到历史版本 90。
| 读取者 | 可能读到的成绩 |
|---|---|
| 保持原有快照的 RR 事务 A | 90 |
| B 提交后新开启并查询的事务 C | 95 |
2. 旧版本保存在哪里?undo log
InnoDB 有一种日志叫 undo log,撤销日志。
修改记录时,会记录支持撤销修改、重建旧版本所需的信息。例如:
UPDATE students SET score = 95 WHERE name = '小红';
可以把相关信息简化理解成:
| 内容 | 作用 |
|---|---|
| 当前记录:95 分 | 保存最新版本 |
| 撤销信息:修改前是 90 分 | 支持回滚,也支持构建历史版本 |
你之前学过的两个现象,背后都与它有关:
- 执行
ROLLBACK:利用撤销信息撤销修改。 - 快照读取旧成绩:利用撤销信息重建历史版本。
但快照读不会执行回滚。 它只是为读取者找到旧版本,当前记录仍然可以是 95。
旧版本也不会永远保留。当不再需要支持相关事务读取时,InnoDB 会逐步清理不再需要的历史信息。
3. 数据库怎么判断我该读哪个版本?Read View
Read View 可以理解为 读取时使用的可见性判断依据。
它不是"把整张表复制一份"。它主要记录创建时的事务情况,用这些信息判断某个记录版本是否可见。
先掌握两个判断:
- 其他事务在快照建立前已经提交的修改,通常可以看到。
- 快照建立时其他事务尚未提交的修改,不能看到;即使它后来提交,原快照也不会因此更新。
同时,事务能够看到自己的修改。
例如按以下顺序执行:
| 顺序 | 事务 A | 事务 B |
|---|---|---|
| 1 | 开启 RR 事务 | |
| 2 | 普通查询小红,读到 90,建立快照 | |
| 3 | 把小红改成 95 | |
| 4 | 提交 | |
| 5 | 再次普通查询,仍读到 90 |
A 在第五步使用原有的 Read View,发现 95 这个版本对自己不可见,于是沿历史版本找到可见的 90。
4. RC 和 RR 为什么读出的结果不同?
区别主要在于:普通一致性读取什么时候建立新的 Read View。
| 隔离级别 | 普通查询的快照规则 |
|---|---|
| RC,读已提交 | 每次一致性读取建立新的 Read View |
| RR,可重复读 | 通常在第一次一致性读取时建立,后续沿用 |
所以:
A 第一次查询:90
B 修改为 95 并提交
A 第二次查询:?
- A 使用 RC:第二次建立新快照,能读到已提交的 95。
- A 使用 RR:沿用旧快照,仍读到 90。
5. 快照读与当前读有什么区别?
你写过的 SQL 可以分成这两类理解:
| 类型 | 示例 | 主要行为 |
|---|---|---|
| 快照读 | 普通 SELECT,在 RC/RR 下 |
按 Read View 读取可见版本,通常不加记录锁 |
| 当前读 | SELECT ... FOR UPDATE、`UPDATE`、`DELETE` |
读取当前可用的最新数据并加相应的锁,必要时等待 |
这里的"当前读"不表示可以读到别人未提交的数据。如果别人持有冲突的锁,它通常需要等待。
在 RR 事务 A 中,可能发生:
-- 第一次普通查询,读到 90
SELECT score FROM student_lock_demo WHERE id = 1;
此时 B 把成绩改成 95 并提交。
A 接着执行:
-- 普通快照读,仍然是 90
SELECT score FROM student_lock_demo WHERE id = 1;
-- 锁定读取,可以读到已提交的 95,并锁住相关记录
SELECT score FROM student_lock_demo WHERE id = 1 FOR UPDATE;
同一个事务里,两条查询可能读到不同的值,因为它们采用了不同的读取方式。 因此,"RR 中所有 SQL 永远看到同一份数据"这个理解不准确。
6. 练习
最后用一道题检验这一节。假设没有其他事务干扰,初始成绩为 90:
A:设置 RR,开启事务
A:普通 SELECT,读到 90
B:把成绩改成 95,提交
A:普通 SELECT
A:SELECT ... FOR UPDATE
A:ROLLBACK
你判断:A 最后两次查询分别是多少?A 的 ROLLBACK 会不会把 B 已经提交的 95 撤销?
90、95,不会撤销 B 的修改。
- 普通
SELECT得到 90:A 使用 RR,沿用第一次普通查询建立的快照,读取旧版本。 SELECT ... FOR UPDATE得到 95:这是当前读,读取 B 已提交的新版本,并锁住相关记录。- A 的
ROLLBACK不会撤销 B 的 95 :回滚只撤销 A 自己事务中的修改。这里 A 没有修改数据,回滚主要是结束事务、释放持有的锁。
因此,A 结束后,新事务查询成绩仍然是 95。
死锁
1. 死锁和普通等待有什么区别?
之前的实验是:
A 锁住一条记录,B 等 A 释放。A 提交后,B 就能继续。
死锁则是:
A 拿着第一条记录的锁,等 B 的第二条记录;B 拿着第二条记录的锁,等 A 的第一条记录。
双方都无法继续,也就无法正常执行到提交释放锁的地方。
| 事务 A | 事务 B |
|---|---|
| 已锁住学生 1 | 已锁住学生 2 |
| 等待学生 2 | 等待学生 1 |
关键是形成了循环等待。
2. 准备两条实验数据
打开两个 MySQL 客户端窗口,分别叫 A、B。两边都执行:
USE student_demo;
ROLLBACK;
在窗口 A 执行一次,准备独立的实验表:
CREATE TABLE IF NOT EXISTS student_deadlock_demo (
id INT PRIMARY KEY,
score INT NOT NULL
) ENGINE=InnoDB;
INSERT INTO student_deadlock_demo (id, score)
VALUES (1, 90), (2, 80)
ON DUPLICATE KEY UPDATE score = VALUES(score);
这张表仅用于实验,不影响原来的 students。
Q:小插曲:假如写错了这句话
id INT PRIMARY KEY,
怎么办?
还没有执行,只是在 -> 后面输入时, 输入:\c,然后按回车,就会取消整条正在输入的 SQL ,回到 mysql>,重新写即可。
3. 按顺序制造死锁
第一步,窗口 A:
START TRANSACTION;
UPDATE student_deadlock_demo
SET score = score + 1
WHERE id = 1;
A 锁住了记录 1,先不提交。
第二步,窗口 B:
START TRANSACTION;
UPDATE student_deadlock_demo
SET score = score + 1
WHERE id = 2;
B 锁住了记录 2,先不提交。
第三步,窗口 A:
UPDATE student_deadlock_demo
SET score = score + 1
WHERE id = 2;
这一步会等待,因为记录 2 被 B 锁着。
第四步,切换到窗口 B:
UPDATE student_deadlock_demo
SET score = score + 1
WHERE id = 1;
现在循环形成了:
- A 等 B 释放记录 2。
- B 等 A 释放记录 1。
在默认开启死锁检测的 InnoDB 中,其中一个事务通常会收到类似错误:
ERROR 1213 (40001): Deadlock found when trying to get lock;
try restarting transaction
不保证一定是 A 或 B 被选中回滚。 另一个事务则可以继续执行。
实验观察结束后,两个窗口都执行:ROLLBACK;
这样也会撤销幸存事务尚未提交的修改。
A的结果

B的结果

4. MySQL 怎么打破死锁?
InnoDB 检测到循环等待后,会选择一个事务作为"牺牲者",回滚它的整个事务,释放它持有的锁。
例如 B 被回滚:
- B 对记录 2 的修改被撤销。
- B 释放记录 2 的锁。
- A 等待的更新可以继续执行。
- A 最后仍需自己执行
COMMIT或ROLLBACK。
注意,数据库帮你回滚了失败事务,但不会自动把这个业务重新执行一遍。
在任意窗口执行下面的命令,可以查看最近一次检测到的死锁详情:
SHOW ENGINE INNODB STATUS\G
输出较长,重点找:
LATEST DETECTED DEADLOCK
其中会记录相关事务、SQL、锁等待和被回滚的事务。这里的 \G 是 MySQL 客户端的竖向展示方式,可以直接执行,不需要再加分号。

5. 写 Java 项目时怎么减少死锁?
最常见的办法是:多条记录按统一顺序操作。
刚才发生死锁,是因为:
A:先更新 1,再更新 2
B:先更新 2,再更新 1
如果都按照主键从小到大操作:
A:先更新 1,再更新 2
B:先更新 1,再更新 2
B 会先在记录 1 上等待,此时还没有锁住记录 2,因此不会形成刚才的循环。
结合你的 updateTwoScores():
java
@Transactional
public void updateTwoScores(...) {
// 更新第一个学生
// 更新第二个学生
}
如果两个请求传入学生的顺序正好相反,就可能形成类似情况。因此,在设计批量更新时,可以先按稳定的规则排列学生,再依次更新。
此外,还应当:
- 缩短事务时间:不要在持有数据库锁时等待用户输入、调用耗时的远程接口。
- 使用合适的索引:减少更新时扫描、锁定的范围。
- 对死锁做有限重试:重新执行整个事务;先确认业务允许重试,不能无限重试。
即使做了这些,复杂业务中仍可能遇到死锁。死锁属于需要处理的并发情况,不代表数据库损坏。
6. 我知道操作系统课程里面讲的死锁,现在你讲的有什么不一样的地方吗?
原理就是操作系统课里讲的死锁,区别主要是:这里竞争的资源是数据库锁,以及数据库会主动检测、回滚某个事务。 你已经懂操作系统死锁,就不需要重新学循环等待,重点看它在数据库里怎样发生和处理。
经典的四个必要条件也能对应:互斥、持有并等待、不可强行剥夺、循环等待。这里数据库通过终止并回滚一个事务,打破这个局面。
数据库特有的地方:SQL 没写锁,也可能持有锁
你执行:
UPDATE students SET score = 95 WHERE name = '小红';
虽然没有写 lock(),InnoDB 仍然会自动获取相应的锁。在显式事务中,相关修改锁通常要等事务提交或回滚才释放。
而且,数据库锁定的资源不一定只是"一条业务记录",还可能涉及索引记录和索引之间的间隙。所以实际锁了什么,与索引、隔离级别、SQL 和执行计划有关。
这才是你后面需要补的数据库知识:从 SQL 判断可能发生哪些锁竞争。
数据库特有的处理:回滚牺牲者,让另一个事务继续
InnoDB 默认开启死锁检测。发现循环后,会选择一个事务,回滚它的整个事务,释放锁,让其他事务继续。
这和"只让某条 SQL 报错"不同。例如:
START TRANSACTION;
UPDATE ...; -- 已成功修改第一条记录
UPDATE ...; -- 此处发生死锁,本事务被选中回滚
第一条更新也会被撤销,因为它属于同一个被回滚的事务。
应用会收到死锁错误。如果需要重试,应当重新执行整个业务事务,而不是只补执行最后一条失败的 SQL。
乐观锁与悲观锁
这一节要解决一个实际问题:两个请求同时修改同一份数据,怎样避免后提交的人覆盖前一个人的修改?
1. 有事务和行锁,为什么还可能覆盖?
假设小红原来是 90 分,两名老师都打开了修改页面:
| 顺序 | 老师 A | 老师 B |
|---|---|---|
| 1 | 查询成绩:90 | |
| 2 | 查询成绩:90 | |
| 3 | 希望加 5 分,提交 95 | |
| 4 | 希望加 2 分,提交 92 |
如果后端执行:
UPDATE students SET score = 95 WHERE name = '小红';
然后执行:
UPDATE students SET score = 92 WHERE name = '小红';
最终是 92。A 的修改被 B 根据旧数据计算出的结果覆盖了。
数据库的行锁能让两条 UPDATE 依次执行,却不会自动判断"你提交的 92 是不是根据过期数据计算的"。
如果业务只是"加分",直接写下面这种原子更新就可以避免这个问题:
UPDATE students
SET score = score + 2
WHERE name = '小红';
但有些业务需要先读取、做复杂判断,再提交修改,这时就需要进一步控制。
2. 悲观锁:先锁住,再处理
你已经用过悲观锁:
START TRANSACTION;
SELECT score
FROM students
WHERE name = '小红'
FOR UPDATE;
-- 根据刚才读取的成绩计算并执行更新
COMMIT;
它的思路是:我处理期间,先阻止别人同时修改相关数据。
注意,锁必须在事务里配合使用。如果查询后事务立刻结束,锁也释放了,就无法保护后面的业务处理。
另外,不适合在老师打开页面时就开启事务,一直等老师填完再提交------用户可能十分钟都不操作,数据库锁不应该一直占着。
3. 乐观锁:提交时检查数据有没有被改过
乐观锁通常给记录增加一个 version 字段,表示版本号。
先用独立实验表练习,不修改原来的项目表。在 MySQL 客户端执行:
USE student_demo;
CREATE TABLE student_version_demo (
id INT PRIMARY KEY,
score INT NOT NULL,
version INT NOT NULL DEFAULT 0
) ENGINE=InnoDB;
INSERT INTO student_version_demo (id, score, version)
VALUES (1, 90, 0);
A、B 查询时,都读到了:score=90 version=0
A 提交修改时,带上自己读取到的版本号:
UPDATE student_version_demo
SET score = 95,
version = version + 1
WHERE id = 1
AND version = 0;
含义是:
只有记录仍然是我之前读取的第 0 版,才允许更新;更新后版本号加 1。
B 再使用自己手里的旧版本号提交:
UPDATE student_version_demo
SET score = 92,
version = version + 1
WHERE id = 1
AND version = 0;
此时数据库里的版本已经是 1,条件不成立,更新影响行数为 0,成绩仍然是 95。
这就是乐观锁的核心:允许大家先读取,提交时再检查冲突。
4. 为什么版本检查要放在 UPDATE 里?
不能这样写:先 SELECT 检查 version 是不是 0,如果是,再 UPDATE。
因为检查与更新之间,别的事务仍然可能修改数据。
把"检查版本"和"修改数据"放进同一条 SQL 中完成。
对应到你熟悉的 JdbcTemplate,核心写法是:
java
int affected = jdbc.update(
"""
UPDATE student_version_demo
SET score = ?, version = version + 1
WHERE id = ? AND version = ?
""",
newScore,
id,
expectedVersion
);
如果 affected == 1,表示更新成功。
如果 affected == 0,表示记录不存在,或者版本已经变化,不能只凭这个结果确定是哪一种。对于已经确认存在的记录,通常需要提示用户刷新数据后重新处理。
在 Web 接口里,版本冲突可以用 409 Conflict 表达。
5. 两种方式怎么区分?
| 对比 | 悲观锁 | 乐观锁 |
|---|---|---|
| 核心思路 | 先获取锁,再处理 | 更新时检查是否发生冲突 |
| 常见实现 | SELECT ... FOR UPDATE |
version 条件更新 |
| 冲突表现 | 等待,也可能死锁或超时 | 条件不匹配,更新失败 |
| 适用例子 | 短事务中锁定数据后完成操作 | 页面编辑后提交,检查数据是否过期 |
还有一个容易误解的地方:乐观锁并不是 UPDATE 完全不加数据库锁。 UPDATE 仍然需要 InnoDB 的锁;"乐观"指业务没有提前锁住记录,而是靠版本条件检测冲突。
你可以先执行第三部分的两条更新,再查询:
SELECT * FROM student_version_demo;
预期结果是 成绩 95、版本 1,因为第二次携带旧版本号的更新被拒绝了。
数据库的三种日志:undo log、redo log、binlog
你已经学过事务和 MVCC,现在正好补上一个问题:数据库怎么撤销修改,又怎么保证重启后数据不丢?
1. 先分清三种日志各自解决什么问题
| 日志 | 中文名称 | 主要用途 |
|---|---|---|
| undo log | 撤销日志 | 事务回滚、为 MVCC 构建历史版本 |
| redo log | 重做日志 | 崩溃恢复,保证已提交修改的持久性 |
| binlog | 二进制日志 | 数据复制、配合备份进行时间点恢复 |
这里讨论的是你使用的 MySQL + InnoDB。undo、redo 属于 InnoDB;binlog 属于 MySQL Server 层。
先别背细节,分别理解"撤销""恢复""记录变更"。
2. undo log:我要撤销刚才的修改
例如:
START TRANSACTION;
UPDATE students
SET score = 95
WHERE name = '小红';
ROLLBACK;
假设小红原来是 90。
为了能够撤销这次更新,InnoDB 会保存相应的撤销信息。回滚后,成绩恢复为 90。
所以可以把 undo log 简化理解为:
保存撤销修改所需要的信息。
它也支持你已经学过的 MVCC:
- 回滚:撤销当前事务的修改。
- 快照读:根据历史信息构建旧版本。
快照读只是读取旧版本,不会撤销当前数据。
3. redo log:已经提交,但还没来得及把数据页写回磁盘怎么办?
数据库不会每次修改一行,就立即把对应的数据页完整写回磁盘。
它通常先修改内存中的数据页,再在合适的时候把数据页写回磁盘。内存中已经修改、尚未写回磁盘的数据页,叫脏页。
于是会出现一个问题:
事务已经提交
内存里是 95
磁盘上的数据页还停留在 90
此时突然断电
如果没有恢复机制,已经提交的 95 就可能丢失。
redo log 用来解决这个问题:
先可靠地记录重做信息,再允许对应的数据页稍后写回磁盘。
这叫WAL, Write-Ahead Logging,预写日志。
在相应日志已经可靠落盘的前提下,即使数据页还没写回,数据库重启时也可以利用 redo log 恢复修改。
注意两个细节:
- redo log 主要记录数据页相关的修改信息,不是简单保存原始 UPDATE SQL。
- 实际提交时日志怎样写入、何时刷盘受配置影响,不能认为任何配置都能保证断电后零丢失。
redo 恢复也不等于"看见日志就把所有事务都算提交"。崩溃恢复还需要判断事务状态,并结合 undo 处理未完成的事务。
4. binlog:记录数据库发生了哪些变更
binlog 更关注数据库层面的变更事件。
例如UPDATE students SET score = 95 WHERE name = '小红';
binlog会按配置的格式记录相关变更。他不一定记录成这句原始SQL,也可能记录行的变化。
它有两个典型用途。
用途一:主从复制。
一台数据库作为主库接收修改,另一台数据库读取并应用相关变更,从而同步数据。
用途二:配合备份恢复数据。
假设:
- 凌晨 2 点做了完整备份。
- 上午不断有新数据写入。
- 上午 10 点误删了数据。
可以先恢复凌晨的备份,再应用后续 binlog 中的变更,恢复到误操作之前的合适位置。
所以 binlog 不能简单理解为"撤销按钮"。 常见的时间点恢复过程是"恢复备份,再重放变更",而不是直接执行一个 rollback。
5. 一次 UPDATE,可以怎样串起来理解?
下面是帮助理解的简化过程,并不是完整的内部执行顺序:
START TRANSACTION;
UPDATE students
SET score = 95
WHERE name = '小红';
COMMIT;
| 机制 | 在这次修改中的作用 |
|---|---|
| 行锁 | 协调其他事务对相关记录的冲突操作 |
| undo log | 支持撤销修改,以及读取历史版本 |
| 内存数据页 | 保存修改后的数据 |
| redo log | 支持崩溃后恢复数据页修改 |
| binlog | 记录变更,供复制和恢复使用 |
| 后台刷脏页 | 将修改后的数据页逐步写回磁盘 |
你可以通过三个问题检查自己是否分清了:
- 事务还没提交,自己执行
ROLLBACK:主要依靠 undo。 - 事务已经提交,数据页尚未写回,数据库突然崩溃:恢复主要涉及 redo。
- 需要从凌晨备份恢复到上午误删之前:通常需要备份加 binlog。
下一层才是"redo 与 binlog 怎样保持提交状态一致",也就是 两阶段提交。先把这三种日志各自的作用分清,再学它就顺畅了。
redo log 与 binlog 的两阶段提交
1. 为什么两种日志需要协调?
前面讲过:
- redo log:InnoDB 用它进行崩溃恢复。
- binlog:MySQL 用它记录变更,支持复制和恢复。
同一次修改,两边对"事务到底有没有提交"的判断必须一致。
假设小红从 90 改成 95。如果简单地分两步提交,就可能出问题:
| 简化的提交方式 | 中间突然崩溃的风险 |
|---|---|
| 先确认 redo 提交,再写 binlog | 本机恢复出 95,但 binlog 没有这次修改,复制或恢复时可能缺失 |
| 先写 binlog,再确认 redo 提交 | binlog 包含这次修改,但本机可能将事务判定为未提交 |
问题在于:两边各做一半时,机器可能突然崩溃。
所以需要一个协调过程,让数据库恢复时能够作出一致决定。
2. 两阶段提交怎么执行?
这里讲的是 MySQL Server 与 InnoDB 之间的内部两阶段提交。先按单个事务理解,省略组提交等优化。
一次提交可以简化为:
- InnoDB 将事务置为 prepare,准备状态。
- MySQL 写入事务对应的 binlog。
- InnoDB 将事务置为 commit,提交状态。
这里的两个阶段是:
| 阶段 | 意思 |
|---|---|
| Prepare | 已做好提交准备,但还没有作出最终提交决定 |
| Commit | 确认提交 |
prepare 不是"已经提交一半数据"。 它表示事务处于一种可恢复的中间状态,崩溃后还能根据协调信息决定提交还是回滚。
另外,redo 信息是在事务执行过程中持续产生的,不是直到最后 prepare 时才突然记录整个事务。
3. 不同时刻崩溃,怎么处理?
把"写入"先理解为相关日志已按配置达到所需的持久化条件。恢复时的核心判断可以简化为:
| 崩溃时的状态 | 恢复时怎么办 |
|---|---|
| 事务尚未进入 prepare,也未提交 | 按未提交事务处理,撤销其修改 |
| 已 prepare,但没有对应的完整 binlog 事务记录 | 回滚 |
| 已 prepare,且有对应的完整 binlog 事务记录 | 完成提交 |
| 已有 commit 状态 | 按已提交事务恢复 |
最关键的是第三行:
即使还没来得及记录最终 commit,只要事务已经 prepare,而且完整 binlog 表明它应当提交,恢复时就可以完成提交。
数据库通过事务标识关联两边的信息,不是靠比较两段 SQL 文本判断它们是不是同一笔事务。
这样,在中间步骤崩溃后,也有依据决定最终结果。
(我个人觉得可以理解为一次提交的三个阶段,前中后可以插入4个位置代表这4种情况。)
4. 为什么提交后,客户端仍然可能不知道成功没有?
再考虑一个容易忽略的场景:
- 数据库完成提交。
- 数据库准备向 Java 返回"成功"。
- 网络连接断开。
- Java 收到连接异常。
这时,Java 报错不代表数据库一定没有提交。
它可能只是没有收到成功回复。
因此,如果你的新增接口遇到连接异常后直接无条件重试,有可能重复新增。
你之前的学生姓名主键,能够阻止同一个姓名重复插入。但真实业务通常还会使用独立的请求编号、订单编号等唯一标识,避免同一次业务重复执行。这与后面要学的 幂等性有关。
两阶段提交解决的是日志提交状态的协调,无法保证客户端在任何网络故障下都明确知道结果。
5. 它和你写的 @Transactional 是什么关系?
你目前的调用过程可以这样理解:
| 层次 | 谁负责 | 做什么 |
|---|---|---|
| 业务事务边界 | Spring @Transactional |
将多次数据库操作放进同一个事务 |
| 提交或回滚请求 | Spring 事务管理器、JDBC | 向数据库发出提交或回滚操作 |
| 数据库内部提交 | MySQL、InnoDB | 协调日志、完成事务提交 |
| 崩溃恢复 | MySQL、InnoDB | 根据持久化信息恢复一致状态 |
例如:
java
@Transactional
public void updateTwoScores(...) {
dao.updateScore(...);
dao.updateScore(...);
}
正常执行结束后,Spring 请求数据库提交。数据库内部再完成相应的日志提交过程。
这些 prepare、binlog、commit 步骤,不需要你在 Java 中手动编写。
还有两个名字需要分清:
- 这里讲的是 MySQL 内部两阶段提交。
- 跨多个数据库或服务的 分布式事务两阶段提交,属于另一个层面。
你的学生项目目前是一个 MySQL 数据库上的本地事务,不需要引入分布式事务。