C++转Java日记(14)

最近在追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 的修改。

  1. 普通 SELECT 得到 90:A 使用 RR,沿用第一次普通查询建立的快照,读取旧版本。
  2. SELECT ... FOR UPDATE 得到 95:这是当前读,读取 B 已提交的新版本,并锁住相关记录。
  3. 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 被回滚:

  1. B 对记录 2 的修改被撤销。
  2. B 释放记录 2 的锁。
  3. A 等待的更新可以继续执行。
  4. 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 记录变更,供复制和恢复使用
后台刷脏页 将修改后的数据页逐步写回磁盘

你可以通过三个问题检查自己是否分清了:

  1. 事务还没提交,自己执行 ROLLBACK:主要依靠 undo。
  2. 事务已经提交,数据页尚未写回,数据库突然崩溃:恢复主要涉及 redo。
  3. 需要从凌晨备份恢复到上午误删之前:通常需要备份加 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 之间的内部两阶段提交。先按单个事务理解,省略组提交等优化。

一次提交可以简化为:

  1. InnoDB 将事务置为 prepare,准备状态。
  2. MySQL 写入事务对应的 binlog。
  3. InnoDB 将事务置为 commit,提交状态。

这里的两个阶段是:

阶段 意思
Prepare 已做好提交准备,但还没有作出最终提交决定
Commit 确认提交

prepare 不是"已经提交一半数据"。 它表示事务处于一种可恢复的中间状态,崩溃后还能根据协调信息决定提交还是回滚。

另外,redo 信息是在事务执行过程中持续产生的,不是直到最后 prepare 时才突然记录整个事务。

3. 不同时刻崩溃,怎么处理?

把"写入"先理解为相关日志已按配置达到所需的持久化条件。恢复时的核心判断可以简化为:

崩溃时的状态 恢复时怎么办
事务尚未进入 prepare,也未提交 按未提交事务处理,撤销其修改
已 prepare,但没有对应的完整 binlog 事务记录 回滚
已 prepare,且有对应的完整 binlog 事务记录 完成提交
已有 commit 状态 按已提交事务恢复

最关键的是第三行:

即使还没来得及记录最终 commit,只要事务已经 prepare,而且完整 binlog 表明它应当提交,恢复时就可以完成提交。

数据库通过事务标识关联两边的信息,不是靠比较两段 SQL 文本判断它们是不是同一笔事务。

这样,在中间步骤崩溃后,也有依据决定最终结果。

(我个人觉得可以理解为一次提交的三个阶段,前中后可以插入4个位置代表这4种情况。)

4. 为什么提交后,客户端仍然可能不知道成功没有?

再考虑一个容易忽略的场景:

  1. 数据库完成提交。
  2. 数据库准备向 Java 返回"成功"。
  3. 网络连接断开。
  4. 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 数据库上的本地事务,不需要引入分布式事务。

相关推荐
龙腾AI白云3 小时前
数字孪生与计算机视觉:让机器看懂现场
大数据·数据库·机器学习·知识图谱·pygame
千寻技术帮4 小时前
基于Spring Boot+Vue的农产品销售管理系统(源码+文档+数据库,附部署教程)
java·数据库·spring boot·后端·mysql·vue
千寻技术帮5 小时前
50055_基于AI的互帮互助小程序(源码+文档+数据库脚本+部署教程)
数据库·人工智能·小程序·毕业设计·springboot·课程设计
CoderYanger6 小时前
Java EE 进阶:9.MyBatis 操作数据库(进阶)(第七弹):图书管理系统(强制登录)
java·数据库·spring boot·spring·java-ee·tomcat·mybatis
Flynn Liang6 小时前
多智能体协同不再复杂:Redis Stream 消费者组、幂等与故障恢复
数据库·人工智能·redis·缓存·ai agent·智能体
倔强的胡萝卜8 小时前
基于STM32F103C8T6的温湿度报警器设计
数据库·stm32·mongodb
Decay__15 小时前
PostgreSQL 数据库全栈运维实战系列 — 合集索引(24 篇)
运维·数据库·sql·mysql·架构
琳少_19 小时前
java程序开发笔记
java·开发语言·数据库·笔记
Pocker_Spades_A1 天前
工业物联网时序数据库选型:一份能直接抄走的技术规格书
数据库·物联网·时序数据库