面试题集锦:存储加深(MySQL / 分片等)

通识对照:MySQL 事务隔离与 MVCC:快照读、当前读与间隙锁

面试题集锦:存储加深(MySQL / 分片等)

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。


目标岗位:大型加密货币交易所 · 后端(风控方向)
题目数:18 题
核心主题:MySQL 索引/隔离级别/分库分表、ES 写入优化、列存/时序选型


Q1:MySQL 索引原理

TL;DR

InnoDB 索引 = B+ 树(多路平衡树),主键索引 = 聚簇索引(叶子存整行数据),二级索引 = 叶子存主键值(需回表)。优化:覆盖索引(不回表)+ 最左前缀(联合索引生效)+ 索引下推(ICP 减少回表次数)。

类比

📚 图书馆索书号:主键索引 = 按索书号排的书架(聚簇,书就在这)。二级索引 = 索书号→书名对照表(叶子只存索书号,真正的书还需按号去找 = 回表)。覆盖索引 = 你要的信息在对照表上就有,不用去书架。

B+ 树特性

1. 非叶子节点只存 key(不存数据)→ 单个节点能存更多 key → 树更矮
2. 叶子节点用双向链表连接 → 范围查询极快(走链表就行)
3. 插入/删除保持平衡 → O(logN) 查找

B+ 树 vs B 树:
  B 树每个节点都存数据 → 节点更大 → 树更高 → IO 更多
  B+ 树只叶子存数据 → 节点更小 → 树更矮 → IO 更少 → MySQL 选 B+

覆盖索引

-- 联合索引:(user_id, status, create_time)
-- ✅ 覆盖索引:要查的字段都在索引里,不回表
SELECT user_id, status FROM orders WHERE user_id = 1;
-- 直接读索引页,不碰数据页
 
-- ❌ 需要回表:SELECT * 包含索引没覆盖的字段
SELECT * FROM orders WHERE user_id = 1;
-- 先查索引→拿到主键→再查聚簇索引(回表)

索引下推(ICP)

-- 联合索引:(name, age)
-- 无 ICP:引擎查到所有 name='张%' 的行→返回给 Server 层→Server 过滤 age>18
-- 有 ICP:引擎查 name='张%' 时直接过滤 age>18 → 减少回 Server 层的行数
SELECT * FROM users WHERE name LIKE '张%' AND age > 18;

记忆锚

"B+ 树聚簇、二级回表、联合最左、覆盖免回、ICP 引擎层预过滤"


Q2:MySQL 事务隔离级别 + MVCC + 死锁排查

TL;DR

四种隔离级别:读未提交(脏读)→ 读已提交(不可重复读)→ 可重复读(InnoDB 默认,间隙锁防幻读)→ 串行化(性能最差)。MVCC = undo log + ReadView,每个事务看到数据快照。

类比

📸 数据库中 MVCC = 拍照:事务开始时拍一张快照(ReadView),之后不管别人怎么改,你看到的始终是这张照片。Read Committed = 每次查询重新拍照。Repeatable Read = 事务内一直用同一张。

四种隔离级别

级别脏读不可重复读幻读InnoDB 解决幻读
READ UNCOMMITTED✅✅✅❌ 无
READ COMMITTED❌✅✅❌ 无
REPEATABLE READ❌❌✅间隙锁
SERIALIZABLE❌❌❌全表锁

MVCC 核心

-- 每行有两个隐藏列:
-- DB_TRX_ID:最后修改的事务 ID
-- DB_ROLL_PTR:指向 undo log 的指针
 
-- ReadView:事务启动时的快照
-- 包含:活跃事务列表 + 最小/最大事务 ID
-- 判断:当前行的事务 ID 是否在快照中可见

死锁排查

-- 1. 查看最近死锁
SHOW ENGINE INNODB STATUS\G
-- 搜索 "LATEST DETECTED DEADLOCK"
 
-- 2. 查看当前锁等待
SELECT * FROM information_schema.INNODB_LOCKS;
SELECT * FROM information_schema.INNODB_LOCK_WAITS;
 
-- 3. 查看当前事务
SELECT * FROM information_schema.INNODB_TRX;
 
-- 常见原因:两个事务以不同顺序访问同一组行
-- 解决:统一加锁顺序、缩短事务、使用乐观锁

记忆锚

"RR=快照读+间隙锁,MVCC=undo链+ReadView,死锁=统一锁顺序"


Q3:Slow SQL——测试快生产慢的原因

TL;DR

测试快生产慢 = 数据量差异(1000 行 vs 1000 万行,全表扫描一个能用一个不能)→ 执行计划不同(统计信息过期/数据倾斜)→ 锁竞争(生产并发高,行锁/间隙锁等待)→ Buffer Pool 命中率(生产内存不够,频繁刷盘)。

排查链

-- 1. 看实际执行计划(不是 EXPLAIN 模拟!)
EXPLAIN ANALYZE SELECT ...;
-- 对比测试环境和生产环境的差别
 
-- 2. 看表统计信息是否过期
SHOW TABLE STATUS LIKE 'orders';
-- rows 远小于实际 → 优化器选错索引
 
-- 3. 更新统计信息
ANALYZE TABLE orders;
 
-- 4. 强制走索引对比
SELECT * FROM orders FORCE INDEX(idx_create_time) WHERE ...;
 
-- 5. 锁等待检查
SELECT * FROM sys.innodb_lock_waits;

四个根因

1. 数据量 → 全表扫描 1000 行很快(测试),1000 万行不行(生产)
2. 执行计划 → 统计信息过期 → MySQL 选了"理论上好"但"实际上差"的索引
3. 锁竞争 → 生产 100 并发 → 间隙锁/行锁等待 → 看起来像慢查询
4. Buffer Pool → 生产数据太多缓存不下 → 每次读都要磁盘 IO

记忆锚

"数据量→执行计划→锁竞争→Buffer Pool,依次排查"


Q4:列式存储原理与应用

TL;DR

列存 = 按列而不是按行存储数据。适合 OLAP(聚合查询只扫少数列)。行存适合 OLTP(整行读写)。典型选型:StarRocks / ClickHouse(分析),InnoDB(事务)。

类比

📊 Excel 透视表:行存 = 按每一行存(一行一行的记录)。列存 = 把每一列单独存成一个文件。要算"所有用户的平均余额"→ 行存需扫所有行,列存只需扫余额那一列。

行存 vs 列存

interview storage depth qa · 图 1
interview storage depth qa · 图 1 · 点击查看 SVG 原图
行存(InnoDB)列存(StarRocks/ClickHouse)
写入✅ 快❌ 慢(需拆成多列写)
单行查询✅ 快(一行连续存储)❌ 慢(需拼装多列)
聚合查询❌ 慢(扫全部列)✅ 极致快(只扫目标列)
压缩率一般极高(同列数据相似)
适用OLTP(交易/下单)OLAP(报表/分析)

记忆锚

"行存 = OLTP(交易),列存 = OLAP(分析),聚合查列存快 100 倍"


Q5:时序数据库原理

TL;DR

时序 DB = 专为时间序列数据优化的数据库。核心特性:降采样(1min→5min→1h 自动聚合)、Retention Policy(自动删除过期数据)、高效写入(LSM-Tree / 列存)。选型:InfluxDB / Prometheus / TDengine。

类比

📈 股票 K 线图:原始数据每秒一个 tick → 存的话数据量爆炸。时序 DB 自动把 60 个 1s tick 聚合成 1 根 1min K 线(降采样),3 个月前的 1min K 线再聚合成 1h K 线。查询最近 1 天资料用最细粒度的,查全年趋势用粗粒度的。

核心特性

-- InfluxDB 降采样
CREATE CONTINUOUS QUERY "cq_1h" ON "market_data"
BEGIN
  SELECT mean(price), max(price), min(price)
  INTO "market_data"."autogen"."kline_1h"
  FROM "market_data"."autogen"."ticks"
  GROUP BY time(1h), symbol
END
 
-- Retention Policy
CREATE RETENTION POLICY "one_year" ON "market_data" DURATION 52w REPLICATION 1;

选型对比

InfluxDBPrometheusTDengine
写入性能百万点/s一般千万点/s
查询语言InfluxQL/FluxPromQLSQL
压缩率中中极高(10:1+)
集群企业版Thanos/Cortex 扩展✅ 内置

记忆锚

"降采样 + Retention + 高效写入,时序 DB 不是普通 DB 加个时间戳列"


Q6:双层缓存设计 → 已在 B6 Q5 完整覆盖,此处略。


Q7:MySQL 分库分表策略

TL;DR

分库分表 = 垂直拆分(按业务:用户库/订单库)→ 水平拆分(按 sharding key 分片)。分片键选:user_id(最常用,保证同一用户数据在同一分片)。分片算法:取模(简单但扩容难)→ 一致性哈希(扩容影响小)→ 雪花 ID 自带路由(推荐)。

类比

🗂️ 档案柜分架:垂直分 = 人事档案放 A 柜,财务档案放 B 柜。水平分 = 人事太多,一个柜子不够 → 按员工编号前两位分到 10 个柜子。

分片键选择

✅ 好的分片键:
  - user_id:用户的所有数据在同一个分片(避免跨分片 JOIN)
  - order_id(雪花算法自含分片路由)

❌ 坏的分片键:
  - status:数据倾斜严重(90% 的订单 status=COMPLETED)
  - create_time:热点(当天的数据全在同一个分片)

分片带来的问题

1. 跨分片查询:WHERE user_id IN (... 多个分片)
   → 解决:在应用层 scatter-gather(发 N 个查询→合并结果)

2. 跨分片事务:A 分片扣款 + B 分片入账
   → 解决:Seata AT / Saga / 本地消息表

3. 全局唯一 ID:自增 ID 在不同分片会冲突
   → 解决:雪花算法 / 号段模式 / Redis INCR

4. 扩容:取模 hash → hash%4 变成 hash%8 → 大量数据迁移
   → 解决:一致性哈希 / 预分片(一开始就分 1024 个分片)

记忆锚

"user_id 分片最优,雪花 ID 自带路由,跨分片靠 scatter-gather"


Q8:MySQL vs PostgreSQL

MySQLPostgreSQL
MVCCundo log + ReadView多版本元组(数据页存新旧版本)
JSONJSON 类型,函数较少JSONB(二进制+索引,极强)
复杂查询一般极强(窗口函数/CTE/递归)
扩展一般极强(FDW/自定义类型/PostGIS)
复制异步/半同步/Group Replication流复制(WAL)
适用简单 OLTP(互联网标配)复杂查询 + 分析混合

记忆锚

"MySQL 简单够用(OLTP),PG 功能全面(复杂查询+分析)"


Q9:MongoDB 原理与应用

TL;DR

MongoDB = 文档型 NoSQL,BSON 存储,WiredTiger 引擎(B+ 树 + MVCC)。适用:灵活 Schema(用户画像/风控日志)、嵌入式文档(1:1 关系不用 JOIN)、海量写入(写入 WS 内部缓存,批量刷盘)。与 MySQL 互补。

合适 vs 不合适

✅ 合适:
  - 风控事件日志(字段不固定,每种风险有不同字段)
  - 用户画像(每个用户标签不同,Schema 灵活)
  - 订单簿深度快照(嵌入文档,一次查询拿到全部档位)

❌ 不合适:
  - 资金账户(需要强事务一致性)
  - 多表 JOIN(MongoDB JOIN=aggregation pipeline,性能差)
  - 复杂报表(没有窗口函数,聚合管道难写)

记忆锚

"MongoDB = Schema 灵活 + 嵌入文档,和 MySQL 互补不互替"


Q10:数据库连接池参数调优 + 泄漏排查

TL;DR

HikariCP 核心参数:maximumPoolSize(连接数 = (CPU 核数 × 2) + 有效磁盘数,加监控验证)→ connectionTimeout(等连接的 max 时间,默认 30s)→ idleTimeout(空闲连接回收)。泄漏排查:pool.getActiveConnections() 持续增长 → 查谁拿了连接没还。

类比

🍽️ 餐厅座位:连接池 = 餐厅的桌子。maximumPoolSize = 桌子总数。connectionTimeout = 顾客愿意等多久。连接泄漏 = 有顾客占着桌子不走也不吃饭 → 新顾客无法入座。

HikariCP 配置

spring:
  datasource:
    hikari:
      maximum-pool-size: 10        # CPU 核数*2 + 磁盘数,最多 10
      minimum-idle: 5              # 保持 5 个空闲连接
      connection-timeout: 30000    # 等连接最多 30s
      idle-timeout: 600000         # 空闲 10min 回收
      max-lifetime: 1800000        # 连接最长存活 30min
      leak-detection-threshold: 10000  # 连接持有 >10s → 告警

泄漏排查

// 监控指标
HikariPoolMXBean poolMXBean = hikariDataSource.getHikariPoolMXBean();
int active = poolMXBean.getActiveConnections();  // 活跃连接
int idle = poolMXBean.getIdleConnections();      // 空闲连接
int pending = poolMXBean.getThreadsAwaitingConnection(); // 排队线程
 
// 告警条件:
// active == maximum && pending > 0 → 连接池满了,有人泄漏!
// 开启 leak-detection-threshold → 日志打印持有时间过长的调用栈

记忆锚

"maxPoolSize = CPU×2+磁盘,leak-detection-threshold 抓泄漏,active 打满+排队=告警"


Q11:核心表 DDL 变更平滑操作

TL;DR

大表 DDL 不能直接 ALTER(锁表,业务中断)。方案:pt-online-schema-change(Percona 工具,创建新表+触发器+增量同步)→ gh-ost(GitHub,无触发器,基于 binlog)→ 原生 Online DDL(MySQL 5.6+,仅部分操作支持)。

类比

🏗️ 高速路面翻新:不能封路施工。方案:在旁边修一条临时路(影子表)→ 引导车流慢慢转到新路(触发器同步增量)→ 旧路废弃。

pt-online-schema-change 原理

1. 创建影子表(_new):与原表结构相同 + 新 DDL 变更
2. 在旧表上创建触发器:INSERT/UPDATE/DELETE 同步到影子表
3. 分批复制旧数据到影子表(chunk 方式,不锁表)
4. 数据追平后 → 原子 RENAME TABLE(瞬间切换)
5. 删除旧表和触发器

注意事项

1. 必须有主键(否则 pt-osc 无法按 chunk 分批)
2. 磁盘空间需要原表的 2 倍(影子表占用)
3. 外键(gh-ost 不支持,pt-osc 支持但复杂)
4. 低峰期操作(虽然不锁表,但有 IO 负载)

记忆锚

"pt-osc(触发器同步)或 gh-ost(binlog 同步),建影子表→分批搬数据→RENAME 秒切"


Q12:MySQL 索引失效场景

TL;DR

索引失效七大场景:LIKE '%xx'(前导模糊)→ OR 条件含非索引列→ 联合索引不满足最左前缀→ 索引列上做函数/运算→ 隐式类型转换→ **!= / <>**→ IS NULL 在某些版本。

七大场景

-- 1. 前导模糊
SELECT * FROM users WHERE name LIKE '%三';  -- ❌ 索引失效
SELECT * FROM users WHERE name LIKE '三%';  -- ✅ 走索引
 
-- 2. OR 含非索引列
SELECT * FROM users WHERE id = 1 OR non_index_col = 'x';  -- ❌
 
-- 3. 联合索引不满足最左前缀
-- 联合索引 (a, b, c)
SELECT * FROM t WHERE b = 1;        -- ❌ 不是最左
SELECT * FROM t WHERE a = 1 AND c = 3;  -- ✅ 走 a,c 不走
 
-- 4. 索引列上函数/运算
SELECT * FROM orders WHERE YEAR(create_time) = 2025;  -- ❌
SELECT * FROM orders WHERE create_time >= '2025-01-01'; -- ✅
 
-- 5. 隐式类型转换
SELECT * FROM users WHERE phone = 13800138000;  -- phone 是 VARCHAR,❌ 全表扫
 
-- 6. != / <>
SELECT * FROM users WHERE status != 'DELETED';  -- ❌ 大多数情况不走
 
-- 7. IS NULL(MySQL 某些版本/引擎)
SELECT * FROM users WHERE name IS NULL;  -- 需验证 EXPLAIN

记忆口诀

"模糊开头 OR 非索,联合不左函数棵,隐式转换不等于,NULL 要验"


Q13:MySQL EXPLAIN 分析

TL;DR

EXPLAIN 看三列:type(访问类型,range 以下需优化)→ key(实际使用的索引)→ Extra(Using filesort/temporary 需优化)。目标:type=ref 以上,Extra 无 filesort 和 temporary。

核心列解读

EXPLAIN SELECT * FROM orders WHERE user_id = 1 ORDER BY create_time LIMIT 10;
列含义好→坏排序
type访问类型system > const > eq_ref > ref > range > index > ALL
key实际使用的索引非 NULL(走索引)
rows预估扫描行数越小越好
Extra额外信息Using index(覆盖)=最好, Using filesort=需排序, Using temporary=需临时表=差

type 详解

ALL:全表扫描(最差,必须优化)
index:全索引扫描(稍好,但仍扫描整棵索引树)
range:索引范围扫描(WHERE id > 100)
ref:非唯一索引等值匹配(WHERE user_id = 1)
eq_ref:唯一索引等值匹配(JOIN 时用主键)
const:主键等值匹配(WHERE id = 1)

记忆锚

"type 看访问方式(ALL 必改),key 看用了哪个索引,Extra 看是否有 filesort/temporary"


Q14:什么是幻读?MySQL 如何通过 MVCC + 间隙锁解决?

TL;DR

幻读 = 同一事务内两次读取,第二次多出了新插入的行(像幻觉)。MVCC(快照读) 解决普通 SELECT 的幻读。间隙锁(当前读) 解决 SELECT FOR UPDATE 的幻读,锁住记录之间的间隙。

类比

🚗 停车场找车位:你第一次看(快照读)→ 10 个空位。别人插进来停了(插入)→ 你再想看 → MVCC 让你看到的还是 10 个空位(快照不变)。但如果你要停车(FOR UPDATE)→ 间隙锁已经锁住了这个空位,别人插不进来。

MVCC 快照读

-- 快照读(普通 SELECT,MVCC 保证不幻读)
SELECT * FROM orders WHERE user_id = 1;
-- → 基于 ReadView,看到的是事务开始时的快照

间隙锁(当前读)

-- 当前读(FOR UPDATE,间隙锁防止幻读)
SELECT * FROM orders WHERE user_id = 1 FOR UPDATE;
-- → 锁定满足条件的行 + 行之间的间隙
-- → 其他事务无法在间隙中插入
gap lock 锁范围示例:
 索引值:10, 20, 30
 WHERE id = 20 → 锁住 (10,20] 和 (20,30)
 WHERE id = 25(不存在)→ 锁住 (20,30) ← 防止插入 25

记忆锚

"快照读用 MVCC 不改,当前读用间隙锁不让插——幻读双保险"


Q15:分库分表——分片键 + 跨分片查询

TL;DR

分片键首推 user_id(保证同一用户数据在同一分片)。跨分片查询:Scatter-Gather(并行查所有分片→合并)、全局二级索引(单独建一个索引表)、异构索引(ES 做全文搜索)。

跨分片查询方案

方案 1:Scatter-Gather(最常用)
  → 并发查询所有分片 → 在应用层合并排序
  → 成本:O(N) 分片数,性能可控
  → 适用:分片 ≤ 32 个

方案 2:全局二级索引
  → 建一个索引表:user_id → order_id → 分片位置
  → 先查索引表 → 再定点查对应分片
  → 成本:多一次查询,但避免扫全部分片
  
方案 3:异构索引(ES)
  → 订单数据同步到 ES
  → 复杂搜索走 ES → 拿到主键 → 回 MySQL 查详情
  → CQRS 模式:MySQL 做主存储,ES 做查询

记忆锚

"user_id 分片 + Scatter-Gather 聚合,复杂查询走 ES 异构索引"


Q16:ES 写入性能优化

TL;DR

ES 写入优化五招:批量写入(bulk API,每批 5-15MB)→ 调大 refresh_interval(默认 1s→30s)→ 减少副本(写入时 replica=0,写完再恢复)→ 调大 translog(异步刷盘)→ SSD。

优化清单

// 1. 批量写入(bulk API)
POST _bulk
{ "index": { "_index": "orders", "_id": "1" } }
{ "user_id": 123, "amount": 100 }
// → 比单条写入快 100 倍
 
// 2. 索引模板:写入时设置
PUT _template/risk_template
{
  "index_patterns": ["risk-*"],
  "settings": {
    "number_of_replicas": 0,          // 写入时不建副本
    "refresh_interval": "30s",         // 不实时刷新
    "translog.durability": "async",    // 异步刷盘
    "translog.sync_interval": "30s"
  }
}
 
// 3. 写入完成后再改
PUT risk-2025-01/_settings
{ "number_of_replicas": 1, "refresh_interval": "1s" }

常见优化手段

1. bulk 批量(大缓冲 + 少请求)
2. refresh_interval 30s(默认 1s → 吞吐提升 30 倍)
3. replica=0 写入时(写完再恢复副本)
4. translog async(容忍少量丢失换性能)
5. SSD(随机读写性能 > HDD 100 倍+)
6. 合理分片数(单分片 10-50GB,避免过多小分片)

记忆锚

"bulk 批量 + refresh 延长 + 副本延迟 + translog 异步 + SSD"


Q17:订单/交易分库分表 + 热点账户

TL;DR

订单分片:按 user_id % 128 分 128 个分片。热点账户(交易量极大的用户/商户):拆分操作到子账户(主账户 → N 个子账户 → 汇总查询)。写入分散,查询聚合。

热点账户方案

-- 问题:一个高频用户 user_id=123 所有扣款都打到一个分片 → 分片热点
-- 解决:子账户拆分
 
-- 扣款:随机选一个子账户,降低热点
UPDATE account_sub_5 SET balance = balance - 100 WHERE user_id = 123;
 
-- 查询余额:汇总所有子账户
SELECT SUM(balance) FROM account_subs WHERE user_id = 123;

记忆锚

"user_id 分片订单,热点账户拆子账户——写入分散,查询 SUM 汇总"


Q18:ES 海量行情日志快速检索

与 B1 Q34、B8 Q15 重叠。此处给精简版:

架构:
  行情日志 → Kafka → Logstash → ES Hot 节点(SSD, 7天) → Warm 节点(HDD, 90天)

检索:
  按交易对+时间范围 → Date Histogram 聚合(K线查询)
  按用户+时间 → Term Query(审计查询)
  异常检测 → Pipeline Agg(1 分钟内同一用户 > 50 笔告警)

总结

MySQL 索引 → B+ 树 + 聚簇 + 覆盖 + 最左前缀
隔离级别   → RR = MVCC 快照读 + 间隙锁当前读
分库分表   → user_id 分片 + 雪花 ID + Scatter-Gather
列存/时序  → OLAP 用列存,时间序列用时序 DB(降采样+Retention)
ES 优化    → bulk + refresh 延长 + replica 延迟
慢查询     → EXPLAIN type/rows/Extra + 统计信息过期

B12 补充:存储深度追问(Q19-Q29)

来自 questions.md 一面弱项:ACID、事务隔离级别、PostgreSQL vs MySQL、MongoDB。


Q19:ACID 深入——InnoDB 如何保证每个字母?

字母含义InnoDB 实现机制一句话
A 原子性全成功或全回滚undo log(回滚段)— 记录旧值,失败时回放"后悔药"
C 一致性约束不被破坏由 A+I+D 共同保证 + 业务层校验"联手作业"
I 隔离性并发互不干扰MVCC(快照读)+ 锁(行锁/间隙锁,当前读)"透明隔间"
D 持久性提交后不丢redo log(WAL,先写日志再写磁盘)+ doublewrite(防半写)"铁板钉钉"

undo log 为什么保原子性?

UPDATE balance=100 → balance=50
undo log 记录:balance 旧值=100, 事务ID=tx001
→ 事务失败 → 根据 undo log 把数据改回 100(回滚)

redo log 为什么保持久性?

UPDATE balance=50 → 先写到 redo log(顺序写,快)→ 再异步刷数据页
→ 即使数据库崩溃 → 重启后重放 redo log → 数据恢复
→ WAL(Write-Ahead Logging):日志先行

记忆锚

"undo 后悔药保原子,redo 铁板钉钉保持久,MVCC+锁保隔离,三合一保一致"


Q20:MySQL 四种事务隔离级别详解

级别脏读不可重复读幻读InnoDB 默认?原理
READ UNCOMMITTED✅✅✅❌不加锁,直接读最新值
READ COMMITTED❌✅✅❌每次读创建新 ReadView
REPEATABLE READ❌❌⚠️ 部分防✅事务开始创建 ReadView + 间隙锁
SERIALIZABLE❌❌❌❌所有读加共享锁,串行化

脏读 / 不可重复读 / 幻读 的区别

脏读:读到别人未提交的数据(ROLLBACK 了就没了)
  例:A 改了余额=50(未提交),B 读到 50,A 回滚→B 读到了不存在的数据

不可重复读:同一事务两次读同一行,结果不同(别人 UPDATE 了)
  例:A 读到余额=100,B 改成 50 并提交,A 再读=50

幻读:同一事务两次查询,多出了新行(别人 INSERT 了)
  例:A SELECT WHERE amount>100 → 5 行,B INSERT 一行 amount=200 并提交
     A 再 SELECT → 6 行(多了"幻影"行)

开发中如何选择?

默认用 RR(InnoDB 的默认值,MVCC 快照读 + 间隙锁防幻读,99% 够用)

需要 RC 的场景:
  - 高并发写入(RC 没有间隙锁,锁冲突少)
  - 短期事务(读一次就结束,不关心"不可重复读")
  
绝对不用 RU(脏读=读到别人随时可能消失的数据)

几乎不用 SERIALIZABLE(性能太差,MVCC+锁已够用)

记忆锚

"RR=快照读(MVCC)+当前读(间隙锁),InnoDB 默认,脏/不可重复/幻三种异常递进"


Q21:PostgreSQL vs MySQL 深入对比

MySQL (InnoDB)PostgreSQL
MVCC 实现undo log 存旧版本 → ReadView 判断可见性数据页直接存多版本元组(无 undo log 回滚段)
事务回滚需回放 undo log → 大事务回滚慢直接标记旧元组 → 回滚极快
JSONJSON 类型,函数少JSONB(二进制压缩 + GIN 索引)→ 函数极丰富
DDL 事务❌ DDL 不能回滚✅ DDL 也在事务内(CREATE TABLE 可回滚)
复制异步/半同步/GROUP REPLICATION流复制(WAL Sender) + 逻辑复制(更灵活)
复杂查询窗口函数 8.0+,CTE 8.0+天生强:递归 CTE、LATERAL JOIN、窗口函数
发布时间19951996(但 PG 更"学院派",功能更先进)

选型建议

✅ 选 MySQL:
  - 互联网标配(团队熟悉 + 运维工具成熟)
  - 简单 OLTP(读多写少,主从读写分离)
  - 需要成熟的中间件(分库分表:ShardingSphere)

✅ 选 PostgreSQL:
  - 复杂查询多(窗口函数、递归 CTE、地理查询 PostGIS)
  - 需要事务性 DDL(部署脚本 `BEGIN; ALTER TABLE...` 可回滚)
  - 需要 JSONB 全文索引(代替 MongoDB 做文档存储)
  - 金融/合规(PG 的 MVCC 更严格,无"脏读"概念)

记忆锚

"MySQL 简单易用(互联网标配),PG 功能强大(复杂查询+事务DDL+JSONB),回滚 PG 秒回 MySQL 可能卡"


Q22:MongoDB 适用场景 + 与 MySQL 互补

TL;DR

MongoDB = 文档数据库,适合 Schema 灵活(风控事件字段不确定)+ 嵌入式文档(1:1 关系不用 JOIN)+ 海量 JSON 写入。和 MySQL 互补,不是替代。

✅ 适合 MongoDB:
  - 风控事件日志(不同风险类型字段完全不同)
  - 用户画像(标签不确定,随时增加新维度)
  - 行情深度快照(一次查询拿到全部档位 → 文档型天然)

❌ 不适合 MongoDB:
  - 资产扣减(需要事务 + 行锁)
  - 多表 JOIN(MongoDB aggregation pipeline 性能远不如 SQL JOIN)
  - 需要严格 Schema 约束(如资金账户字段不能少)

Q23:分库分表后全局唯一 ID 方案

方案原理优点缺点
雪花算法时间戳+机器ID+序列号高性能,趋势递增时钟回拨问题
号段模式每次从 DB 取一段 ID(如 step=1000)简单,强递增依赖 DB
Redis INCR原子递增简单持久化可能丢
UUID随机生成完全无依赖字符串长,索引差

记忆锚

"雪花 ID 是标准答案——趋势递增 + 不依赖 DB + 高性能。但要处理时钟回拨"


Q24:MySQL 为什么用 B+ 树而不是 B 树 / 红黑树 / Hash?

  • 为什么不是 B 树? B 树节点也存数据 → 节点更大 → 树更高 → IO 更多。B+ 树叶子链表 → 范围查询快
  • 为什么不是红黑树? 二叉树太深(百万数据 ~20 层 = 20 次 IO),B+ 树 3-4 层搞定
  • 为什么不是 Hash? Hash 不支持范围查询,B+ 树叶子链表天然支持 BETWEEN

Q25:MySQL 故障切换机制

机制简述
异步复制主库写 → 异步传 binlog 给从库 → 主库挂了可能丢数据
半同步复制主库写 → 至少一个从库确认收到 binlog → 才返回成功
MGR(组复制)Paxos 协议 → 多数节点确认 → 自动故障切换(MySQL 5.7+)

Q26:Redis 做消息队列 vs Kafka

Redis List/StreamKafka
持久化RDB/AOF(可能丢)磁盘 + 副本(几乎不丢)
吞吐高(纯内存)极高(顺序 IO + 零拷贝)
消费模式RPOP/LPOP 或 Stream 消费组Consumer Group 多分区
适用轻量级、可容忍丢失核心业务、不可丢

Q27:MySQL 索引失效总结 → 已在 B12 Q12 覆盖,此处略。


Q28:数据库连接池最佳大小

公式:connections = ((core_count * 2) + effective_spindle_count)
  → 4 核 + 1 SSD → 9 个连接

原因:连接太多 → 上下文切换 + 锁竞争 > 并行收益
     HikariCP 文档:connection = ((2 * CPU) + Disk)

实际验证:监控 HikariCP 指标
  → ActiveConnections 长期接近 max → 考虑 SQL 优化或增大
  → ActiveConnections 很少用满 → 不需要调

Q29:分库分表 vs TiDB 等分布式数据库

分库分表TiDB
SQL 兼容有限(跨分片 JOIN 难做)MySQL 协议全兼容
扩缩容需要重新分布数据(痛苦)自动重均衡
运维中间件 + 多 MySQL 节点维护统一集群
成熟度成熟(互联网验证 10 年+)较新(2018+)

总结

ACID     → undo 原子 + redo 持久 + MVCC&锁隔离 = 一致
隔离级别 → RR 是 InnoDB 默认,快照读(MVCC) + 当前读(间隙锁)
PG 对比  → PG 功能更全(回滚快+JSONB+事务DDL),MySQL 运维更成熟
B+ 树    → 3-4 层百万数据,叶子链表天然范围查询
连接池   → (CPU×2)+磁盘数,监控 HikariCP 验证

下一篇:B13 Java 并发底层原理(10 题)