面试题集锦:存储加深(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 列存
| 行存(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;选型对比
| InfluxDB | Prometheus | TDengine | |
|---|---|---|---|
| 写入性能 | 百万点/s | 一般 | 千万点/s |
| 查询语言 | InfluxQL/Flux | PromQL | SQL |
| 压缩率 | 中 | 中 | 极高(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
| MySQL | PostgreSQL | |
|---|---|---|
| MVCC | undo log + ReadView | 多版本元组(数据页存新旧版本) |
| JSON | JSON 类型,函数较少 | 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 → 大事务回滚慢 | 直接标记旧元组 → 回滚极快 |
| JSON | JSON 类型,函数少 | JSONB(二进制压缩 + GIN 索引)→ 函数极丰富 |
| DDL 事务 | ❌ DDL 不能回滚 | ✅ DDL 也在事务内(CREATE TABLE 可回滚) |
| 复制 | 异步/半同步/GROUP REPLICATION | 流复制(WAL Sender) + 逻辑复制(更灵活) |
| 复杂查询 | 窗口函数 8.0+,CTE 8.0+ | 天生强:递归 CTE、LATERAL JOIN、窗口函数 |
| 发布时间 | 1995 | 1996(但 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/Stream | Kafka | |
|---|---|---|
| 持久化 | 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 题)