Skip to content

4.1-3 MVCC:ReadView、当前读/快照读、RC/RR ​

所属:04 数据存储 / 4.1 MySQL 分级:A 状态:◐ 初稿 关联:4.1-1、4.1-2、4.1-4、4.1-10、4.1-13

  • 题型:原理 / 流程 / 对比

  • 一句话结论:InnoDB 的 MVCC 不是复制一份数据快照,而是“聚簇索引行上的 DB_TRX_ID/DB_ROLL_PTR + undo 版本链 + ReadView 可见性判断”。普通 SELECT 是快照读,按 ReadView 找可见版本;SELECT ... FOR UPDATE、UPDATE、DELETE 是当前读,读最新版本并加锁。RC 每条语句新建 ReadView,RR 在事务第一次一致性读时建 ReadView;RR 的快照读可重复,锁定读靠 next-key lock 防插入,但“快照读 + 当前读”混用仍可能看到新行。

  • 分层要点:

    1. MVCC 的边界:MVCC 只服务于“一致性读/快照读”,解决读写不互相阻塞;它不解决写写冲突,写写仍靠行锁。普通 SELECT 不加行锁,但会加 page latch;SELECT ... FOR UPDATE/FOR SHARE、UPDATE、DELETE 都是当前读,读最新已提交版本并加锁。把 MVCC 说成“读不加锁”只对普通 SELECT 成立。
    2. 行内隐藏列与版本链:InnoDB 聚簇索引行有 DB_TRX_ID(6 字节,最后修改该行的事务 id)、DB_ROLL_PTR(7 字节,指向 undo 记录)、必要时 DB_ROW_ID(6 字节,无主键/唯一非空索引时)。行被更新时,InnoDB 在 undo 中写前镜像,更新当前行的 DB_TRX_ID/DB_ROLL_PTR;旧版本通过 roll pointer 串成链。MVCC 的“多版本”主要在 undo,不是每行复制一份完整历史。
    3. undo 记录类型:insert undo 只用于回滚插入,提交后即可清理;update undo 保存前镜像并带 previous roll pointer,是版本链的主体;delete 不是立刻物理删除,而是 delete-mark,记录 undo,等 purge 在没有 ReadView 需要时再物理删除。回滚 delete 会清掉删除标记,回滚 update 会用 undo 恢复前镜像。
    4. ReadView 结构:ReadView 记录创建时的活跃读写事务 id 列表 m_ids、最小活跃 id m_up_limit_id(旧称 min_trx_id)、创建时下一个事务 id m_low_limit_id(旧称 max_trx_id)、创建者 m_creator_trx_id。判断版本是否可见:自己的修改可见;trx_id < up_limit 可见;trx_id >= low_limit 不可见;在 m_ids 中不可见;否则可见。关键是“活跃列表 + 边界”,不是简单比较提交时间。
    5. ReadView 创建时机:RC 每条一致性读语句创建一个新 ReadView,所以同一事务两次 SELECT 可能看到不同已提交数据;RR 在事务第一次一致性读时创建,之后复用;START TRANSACTION 本身不创建 ReadView,START TRANSACTION WITH CONSISTENT SNAPSHOT 才会立即创建(RR 下常用)。这个差异是面试高频陷阱:RR 下“BEGIN 之后、第一条 SELECT 之前”别人提交的数据,第一条 SELECT 可能看得见。
    6. 当前读与快照读:快照读按 ReadView 选可见版本,可能读 undo 旧版本;当前读读最新已提交版本,并加锁。SELECT ... FOR UPDATE 是 X 锁 + next-key lock,SELECT ... FOR SHARE 是 S 锁 + next-key lock;UPDATE/DELETE 也是当前读。RC 下当前读主要是 record lock,RR 下是 next-key lock;所以 RC 更容易出现幻读,RR 的锁定读用间隙锁防插入。
    7. RC/RR 与幻读:RC 每条语句新快照,普通 SELECT 也能看到新提交行,幻读明显;RR 的普通 SELECT 在同一个 ReadView 下可重复,但 SELECT ... FOR UPDATE/UPDATE 是当前读,能看到快照之后提交的行。RR 的 next-key lock 只能防止“锁定读扫描范围内”的插入;如果事务先快照读、后当前读,仍可能出现“同一事务看到新行”的现象,所以不能说 RR 在所有语义下完全消灭幻读。
    8. purge 与长事务:undo 版本不是永久保留;purge 线程按最老的 ReadView 清理不再需要的 undo 和 delete-marked 行。长事务/长 ReadView 会阻止 purge,导致 History list length 上涨、undo 表空间膨胀、版本链变长、查询变慢,甚至磁盘打满。监控 History list length、information_schema.innodb_trx 的长事务,必要时拆分事务或 kill。
  • 图/流程:

text
聚簇索引行(当前版本)
  DB_TRX_ID = 100
  DB_ROLL_PTR ──→ undo record(前镜像,DB_TRX_ID=90,roll_ptr→…)
                         │
                         └──→ 更早版本(DB_TRX_ID=80,…)

ReadView(创建时):
  m_ids = [100]          -- 活跃读写事务
  up_limit_id = 100      -- 最小活跃
  low_limit_id = 101     -- 下一个事务 id
  creator_trx_id = 200

判断行版本 100:
  100 在 m_ids → 不可见
  → 顺着 DB_ROLL_PTR 找 90
  90 < up_limit → 可见,返回旧版本
text
ReadView 可见性判定(按顺序):
  trx_id == creator_trx_id        → 可见(自己的修改)
  trx_id <  up_limit_id           → 可见(创建前已结束)
  trx_id >= low_limit_id          → 不可见(创建后才开始)
  trx_id ∈ m_ids                  → 不可见(创建时仍活跃)
  否则                             → 可见(创建前已提交)
text
快照读 vs 当前读:
普通 SELECT
  → ReadView → 可能沿 undo 版本链找旧版本 → 不加行锁

SELECT ... FOR UPDATE / FOR SHARE
UPDATE / DELETE
  → 读最新已提交版本 → 加 X/S 锁(RC record,RR next-key)
  → 可能等待其他事务释放锁
text
RC:
  SELECT → 新 ReadView → 看到最新已提交
  SELECT → 又新 ReadView → 可能看到不同结果(幻读)

RR:
  第一条一致性读 → 建 ReadView,事务内复用
  普通 SELECT → 快照稳定
  SELECT ... FOR UPDATE / UPDATE → 当前读,可能看到快照后新提交行
  • 版本/源码锚点:

    • MySQL 5.7/8.0 默认隔离级别都是 REPEATABLE READ;transaction_isolation 控制。
    • MySQL 8.0:SELECT ... FOR SHARE 替代 LOCK IN SHARE MODE;SKIP LOCKED/NOWAIT 可用于当前读;innodb_locks_unsafe_for_binlog 已移除;默认 binlog_format=ROW。
    • MySQL 8.0 undo:innodb_undo_tablespaces 默认 2;支持 innodb_undo_log_truncate、innodb_max_undo_log_size、innodb_purge_rseg_truncate_frequency。
    • 源码:storage/innobase/read/read0read.cc(ReadView、MVCC、read_view_open_now)、trx/trx0trx.cc(trx_assign_read_view、trx_commit)、trx/trx0sys.cc(trx_sys、max_trx_id)、trx/trx0undo.cc(undo 记录/roll pointer)、trx/trx0purge.cc(purge)、row/row0sel.cc(row_search_mvcc、row_vers_build_for_consistent_read、row_sel_get_clust_rec_for_mysql)、lock/lock0lock.cc(lock_clust_rec_read_check_and_lock)、handler/ha_innodb.cc(隔离级别入口)。
    • 关键结构:ReadView::m_ids/m_up_limit_id/m_low_limit_id/m_creator_trx_id、trx_t::read_view、trx_sys->rw_trx_ids、trx_sys->max_trx_id、DB_TRX_ID、DB_ROLL_PTR、DB_ROW_ID。
  • ReadView 字段:

字段含义易错点
m_ids创建时活跃的读写事务 id 列表创建时活跃、后来提交的事务仍不可见
m_up_limit_id(min_trx_id)最小活跃事务 id小于它的版本可见,不是“最小已提交”
m_low_limit_id(max_trx_id)创建时下一个将分配的事务 id不是“最大活跃 id”;大于等于它的版本不可见
m_creator_trx_id创建 ReadView 的事务 id自己的修改总是可见
  • 可见性判定:
条件结果说明
trx_id == creator_trx_id可见本事务自己的修改
trx_id < up_limit_id可见创建前已结束的事务
trx_id >= low_limit_id不可见创建后才开始的事务
trx_id ∈ m_ids不可见创建时仍活跃,哪怕后来提交
其他可见创建前已提交且不在活跃列表
  • 隔离级别对比:
级别快照/读视图普通 SELECT当前读锁幻读
READ UNCOMMITTED不做一致性快照可能读未提交写操作仍有锁可能
READ COMMITTED每条语句新建最新已提交主要 record lock可能
REPEATABLE READ事务第一次一致性读建,事务内复用快照稳定next-key lock快照读稳定;混用当前读仍可能看到新行
SERIALIZABLE普通 SELECT 也加锁当前读S/X next-key基本避免,但阻塞/死锁增加
  • 当前读/快照读对比:
SQL类型读哪个版本锁
普通 SELECT快照读ReadView 可见版本,可能来自 undo不加行锁,加 page latch
SELECT ... FOR UPDATE当前读最新已提交X + next-key(RC 主要 record)
SELECT ... FOR SHARE当前读最新已提交S + next-key(RC 主要 record)
UPDATE / DELETE当前读最新已提交X + next-key;RC 可 semi-consistent read
INSERT当前读唯一性检查读最新插入意向锁/间隙锁,可能死锁
SELECT ... FOR UPDATE SKIP LOCKED当前读最新已提交跳过已锁行,适合队列
SELECT ... FOR UPDATE NOWAIT当前读最新已提交锁冲突立即报错,不等待
  • purge / undo 关键参数:
参数/指标作用生产提示
innodb_purge_threadspurge 线程数,默认 4高写入/大事务可评估增加
innodb_purge_batch_size每轮 purge 处理量,默认 300太小 purge 跟不上
innodb_max_purge_lagHistory list 过长时延迟 DML给 purge 让路,但会增加写延迟
innodb_max_purge_lag_delay最大延迟时间与上者配合,避免无限等待
innodb_undo_tablespacesundo 表空间数量,默认 2truncate 至少需要 2 个
innodb_undo_log_truncate在线截断 undo 表空间需配合 undo 表空间和 purge
innodb_max_undo_log_size触发 truncate 的 undo 大小结合磁盘和长事务评估
History list length未 purge 的 undo 记录量长事务/长 ReadView 会推高
  • 深挖点(面试官常追的 5 个):

    1. ReadView 不是数据快照:它只是可见性规则;旧版本来自 undo 版本链。能讲清“ReadView 判断 + roll_ptr 回溯”才算真懂 MVCC。
    2. RR 的 ReadView 不是 BEGIN 时创建:是第一次一致性读创建;START TRANSACTION WITH CONSISTENT SNAPSHOT 才是立即创建。这个点能区分背概念和读过实现。
    3. max_trx_id 不是最大活跃 id:它是创建时的“下一个事务 id”;大于等于它的版本一定不可见。活跃列表才决定“创建时还活着”的事务。
    4. RR 不是所有场景都无幻读:普通 SELECT 快照稳定;当前读能看到快照后提交的行,next-key 只锁扫描范围。混用快照读/当前读时,语义要讲清楚。
    5. purge 被最老 ReadView 卡住:长事务不只是“自己慢”,还会让 undo 不能清理、History list 上涨、全库写性能和磁盘受影响。
  • 追问链:

    1. 什么是 MVCC? → InnoDB 用行的 DB_TRX_ID/DB_ROLL_PTR、undo 版本链和 ReadView 实现一致性读;普通 SELECT 读可见旧版本,读写不互相阻塞。
    2. MVCC 和锁是什么关系? → MVCC 解决读-写并发;写-写仍靠行锁。普通 SELECT 不加行锁,但当前读(FOR UPDATE/UPDATE/DELETE)会加锁。
    3. 聚簇索引行有哪些隐藏列? → DB_TRX_ID(6 字节,最后修改事务 id)、DB_ROLL_PTR(7 字节,指向 undo)、必要时 DB_ROW_ID(6 字节,无主键/唯一非空索引时)。
    4. 没有主键时 InnoDB 怎么组织聚簇索引? → 优先选第一个非空唯一索引;没有就用 DB_ROW_ID 生成聚簇索引。主键选择会影响二级索引大小和回表成本。
    5. undo 记录有哪些类型? → insert undo 用于回滚插入;update undo 保存前镜像并串版本链;delete 先 delete-mark,记录 undo,purge 再物理删除。
    6. 版本链是怎么串起来的? → 当前行 DB_ROLL_PTR 指向 undo 记录;undo 记录里保存前镜像和更早的 roll pointer;可见性不满足就继续回溯。
    7. ReadView 里有哪些字段? → m_ids 活跃读写事务、m_up_limit_id 最小活跃、m_low_limit_id 下一个事务 id、m_creator_trx_id 创建者。
    8. ReadView 的可见性算法? → 自己的修改可见;trx_id < up_limit 可见;>= low_limit 不可见;在 m_ids 中不可见;否则可见。
    9. max_trx_id/min_trx_id 怎么理解? → max_trx_id(8.0 的 m_low_limit_id)是创建时下一个事务 id,不是最大活跃;min_trx_id(m_up_limit_id)是最小活跃 id,不是最小已提交。
    10. RC 和 RR 的 ReadView 创建时机? → RC 每条一致性读新建;RR 第一次一致性读建,事务内复用;START TRANSACTION 本身不建,WITH CONSISTENT SNAPSHOT 才立即建。
    11. START TRANSACTION 后别人提交,RR 的第一条 SELECT 能看到吗? → 能,因为 ReadView 在第一条一致性读时才建;要事务开始即固定快照,用 START TRANSACTION WITH CONSISTENT SNAPSHOT。
    12. 快照读和当前读的区别? → 快照读按 ReadView 找可见版本,可能读 undo;当前读读最新已提交并加锁,可能等待其他事务。
    13. SELECT ... FOR UPDATE 读的是快照还是最新? → 当前读,读最新已提交;加 X next-key lock,不是 ReadView 快照。
    14. RC 为什么容易幻读? → 每条语句新 ReadView,能看到新提交行;当前读主要 record lock,不锁间隙,其他事务可插入。
    15. RR 能完全解决幻读吗? → 普通 SELECT 在同一 ReadView 下稳定;锁定读用 next-key 防扫描范围内插入;但快照读后当前读仍可能看到快照后提交的行,不能说所有语义下完全消灭。
    16. RR 的 next-key lock 是什么? → record lock + gap lock,锁住记录和记录之间的间隙;在 RR 下用于 SELECT ... FOR UPDATE/UPDATE/DELETE 防插入。
    17. RC 有 gap lock 吗? → 普通当前读主要 record lock;外键检查和唯一性检查仍可能用间隙锁。RC 下幻读风险更高,常配 ROW binlog。
    18. SERIALIZABLE 怎么实现? → 普通 SELECT 也转成 LOCK IN SHARE MODE 之类的加锁读,走当前读和 next-key;阻塞和死锁增加。
    19. READ UNCOMMITTED 用 MVCC 吗? → 不做一致性快照,可能读到未提交数据;一般不推荐。
    20. RR 下 UPDATE 会看到快照之后插入的行吗? → 会。UPDATE/DELETE 是当前读,读最新已提交;如果新行满足 WHERE,可能被更新,这是“快照读 + 当前读”语义差异。
    21. DELETE 是物理删除吗? → 不是,先 delete-mark;旧 ReadView 仍可通过 undo 看到;purge 确认没人需要后才物理删除。
    22. purge 怎么决定能删哪些 undo? → 找最老的 ReadView,早于它不再需要的 undo/delete-marked 行可以清理;长事务/长 ReadView 会阻塞。
    23. History list length 高说明什么? → 有大量 undo 未被 purge;常见原因是长事务、长 ReadView、purge 跟不上。会导致 undo 膨胀、版本链变长、查询变慢。
    24. 长事务对 MVCC 有什么影响? → 阻止 purge、undo 表空间增长、History list 上涨、版本链变长、崩溃恢复变慢;不只影响自己。
    25. undo 表空间怎么控制? → innodb_undo_tablespaces、innodb_undo_log_truncate、innodb_max_undo_log_size;truncate 需要多个 undo 表空间,且受 purge 影响。
    26. MVCC 在二级索引上怎么实现? → 聚簇索引行有完整 DB_TRX_ID/DB_ROLL_PTR;二级索引叶子存索引键+主键,不保存完整版本链。InnoDB 可用 PAGE_MAX_TRX_ID 做页面级判断,不能判断时回表到聚簇索引做可见性检查,所以覆盖索引不等于完全绕过 MVCC。
    27. ReadView 在高并发下有什么成本? → 创建时要复制活跃事务 id 列表,m_ids 可能很大;RC 每条语句新建,RR 长期持有但会阻塞 purge。高并发长事务要特别关注。
    28. RC 和 STATEMENT 复制有什么关系? → RC 与 STATEMENT 复制存在限制/风险,容易主从不一致;生产建议 binlog_format=ROW,MySQL 8.0 默认也是 ROW。
    29. RR 下 SELECT COUNT(*) 是最新数据吗? → 普通 COUNT 是快照读,RR 下看事务快照,可能不包含之后提交的行;要最新值需当前读或接受快照语义。
    30. SKIP LOCKED/NOWAIT 和 MVCC 什么关系? → 它们是当前读的锁行为:SKIP LOCKED 跳过已锁行,NOWAIT 冲突立即报错;不改变 MVCC 快照规则。
    31. 生产上怎么排查 MVCC 相关问题? → 看 information_schema.innodb_trx 长事务、SHOW ENGINE INNODB STATUS 的 History list length、undo 表空间大小、锁等待/死锁、EXPLAIN 是否走索引;先拆长事务/加索引,再谈隔离级别。
    32. RC 的 semi-consistent read 是什么? → RC 下 UPDATE/DELETE 可以先读最新提交版本,如果行不满足 WHERE 就释放锁、不继续等待;能减少锁等待和死锁,但仍是当前读,不提供快照一致性,也不消除幻读。
  • 生产案例/取舍(示例,替换成你的项目):

    • 报表事务跑了 30 分钟,History list length 持续上涨、undo 表空间翻倍;拆分查询/只读副本后 purge 恢复,写 RT 稳定。
    • 业务在 RR 下先普通 SELECT、后 SELECT ... FOR UPDATE,看到快照之后插入的行,误以为“RR 失效”;实际是快照读/当前读语义不同,改成统一当前读或调整业务判断。
    • RC 下批量 UPDATE 出现幻读/重复处理;确认当前读只锁 record,改为唯一约束/串行化关键段/调整 SQL。
    • SELECT ... FOR UPDATE 的 WHERE 列没索引,锁住大量行和间隙,造成死锁;加索引并缩小事务后解决。
    • 长事务阻塞 purge,undo 磁盘告警;开启 innodb_undo_log_truncate、缩短事务、监控 History list length 后恢复。
    • RC + STATEMENT 复制出现主从数据不一致;切到 ROW binlog 后恢复,RC 继续使用。
    • 高并发下 RR 间隙锁导致死锁率上升;评估后切 RC(配 ROW binlog)降低锁范围,但接受幻读语义变化。
    • SELECT COUNT(*) 在 RR 下与最新数据不一致;报表改用当前读/独立快照/接受延迟。
    • START TRANSACTION 后等待很久再 SELECT,看到等待期间提交的数据;改成 WITH CONSISTENT SNAPSHOT 固定快照。
    • 取舍:RC 换并发/少间隙锁,RR 换热读稳定性;快照读换读性能,当前读换最新性/锁;长事务换业务简单,代价是 purge 和 undo 压力。
  • 易错点:

    • 认为 MVCC 是复制一份数据快照;实际是 ReadView + undo 版本链。
    • 认为 ReadView 在 START TRANSACTION 时创建;RR 是第一次一致性读,WITH CONSISTENT SNAPSHOT 才立即。
    • 认为事务 id 是时间戳/提交顺序;它只是分配顺序,大小不等于提交先后。
    • 认为 max_trx_id 是最大活跃事务 id;它是创建时的下一个事务 id。
    • 认为 min_trx_id 是最小已提交事务 id;它是最小活跃事务 id。
    • 认为 RR 完全解决幻读;快照读和当前读混用时仍可能看到新行。
    • 认为 RC 没有间隙锁就一定没有幻读;当前读仍可能看到新提交行。
    • 认为普通 SELECT 会加行锁;它不加行锁,但当前读会。
    • 认为 SELECT ... FOR UPDATE 读快照;它是当前读。
    • 认为 MVCC 解决写写冲突;写写仍靠锁。
    • 认为 undo 只用于回滚;它还支撑 MVCC。
    • 认为 undo 是永久历史;purge 会清理。
    • 认为 DELETE 立即物理删除;实际先 delete-mark。
    • 认为长事务只影响自己;它会阻塞 purge、影响全库。
    • 认为 History list length 高一定是 undo 文件大;它反映未 purge 的 undo 记录,可能只是 purge lag。
    • 认为覆盖索引完全不需要回表做 MVCC 判断;二级索引不保存完整版本链,必要时仍要回表。
    • 认为 RC 可以随便配 STATEMENT 复制;存在一致性风险。
    • 认为 SERIALIZABLE 没有代价;阻塞和死锁明显增加。
    • 认为 READ UNCOMMITTED 也用 ReadView;它可能直接读未提交。
    • 认为 SKIP LOCKED 能解决所有锁等待;它只跳过已锁行,不改变快照语义。
  • 30 秒口述稿:

InnoDB 的 MVCC 是 undo 版本链加 ReadView。聚簇索引行有 DB_TRX_ID 和 DB_ROLL_PTR,更新时把前镜像写 undo,roll_ptr 串成版本链。ReadView 记录创建时的活跃事务 m_ids、最小活跃 up_limit、下一个事务 id low_limit 和创建者;按 id 判断版本是否可见。RC 每条语句新建 ReadView,RR 第一次一致性读建、事务内复用;START TRANSACTION 本身不建。普通 SELECT 是快照读,FOR UPDATE/UPDATE/DELETE 是当前读并加锁;RR 的 next-key 防锁定读插入,但快照读和当前读混用仍可能看到新行。长事务会阻止 purge,导致 History list 和 undo 膨胀。

  • 3 分钟展开顺序:结论(undo 版本链 + ReadView,不是数据快照)→ 隐藏列/版本链 → undo 类型与 delete-mark → ReadView 字段和可见性算法 → RC/RR 创建时机 → 快照读/当前读 → RC/RR 幻读与 next-key → purge/长事务/undo → 二级索引与覆盖索引 → 生产案例与易错点。