← 返回首页 🔍 追问串联
📐 学习维度 本篇是 🔍 追问串联 🏠 首页 🛤️ 学习路径 📚 全部文章
📑 本篇章节导航 (共11章,点击直达)
🎯 本文在学习路径中的位置核心要点:五分钟心智模型:「四大一致性内核深挖」一、8大规则实战(结合代码理解)二、追问链三、redo log核心(WAL机制)四、两阶段提交(redo + binlog一致)五、ISR管理(复习+深挖)六、unclean leader选举(高频)真题来源相关页面🚀 下一篇

🎯 本文在学习路径中的位置

📍 L4 存储阶段 · Day 4-13 · 综合追问精讲 7

核心要点:五分钟心智模型:「四大一致性内核深挖」

把本文 4 个内核想成一座金融交易所的四大一致性保证——内存可见、清算依赖、崩溃恢复、副本同步:

① 行情同步广播 — happens-before 8 大规则

交易所每个交易员(线程)看到的市场数据必须一致。happens-before 就是「前一个操作的结果对后一个操作可见」的承诺。8 大规则:

实战关键:8 大规则本质是禁用重排序的承诺,不是「立即对其他线程可见」的保证。volatile 写只对后续 volatile 读可见,之前已写的普通变量也通过传递性可见。

② 清算依赖图 — Spring 三级缓存循环依赖

清算时 A 账户依赖 B,B 又依赖 A → 循环依赖。Spring 用三级缓存解决:


一级 singletonObjects      —— 完整 Bean(已完成初始化)
二级 earlySingletonObjects —— 提前暴露的半成品 Bean(已实例化未注入)
三级 singletonFactories    —— ObjectFactory 工厂(lambda 提前生成半成品引用)

完整流程(A 互引 B):

1. 创建 A,实例化后把 A 的 ObjectFactory 放入三级缓存

2. A 注入 B,发现 B 不在一级缓存

3. 创建 B,实例化后把 B 的 ObjectFactory 放入三级缓存

4. B 注入 A,从三级缓存拿到 A 的 ObjectFactory → 调用 getObject() 生成 A 的早期引用 → 放入二级缓存 → A 注入给 B

5. B 完成初始化,放入一级缓存

6. A 继续注入 B(从一级缓存拿到完整的 B),A 完成初始化,放入一级缓存

为什么需要三级而不是二级? —— 三级缓存的 ObjectFactory 是 lambda 延迟执行,支持 AOP 代理(需要时再生成代理对象)。如果只有二级缓存,AOP 代理必须在实例化后立即生成,违反 Spring「初始化完成才生成代理」的设计。

③ 崩溃恢复双保险 — MySQL redo log + WAL

交易所任何交易记录必须崩溃不丢。MySQL 用 WAL(Write-Ahead Logging):先写 redo log(顺序写超快),再写数据页(随机写慢)。崩溃后从 redo log 重做(redo)未落盘的修改,保证 crash-safe。

两阶段提交(redo log + binlog):

1. Phase 1 Prepare —— InnoDB 写 redo log,标记 PREPARE

2. Phase 2 Commit —— 写 binlog → 标记 redo log COMMIT

崩溃恢复规则:

vs L4-12 MVCC undo log:undo log 是回滚(事务未提交),redo log 是重做(事务已提交但数据未落盘)。两者配合 InnoDB 双向可恢复。

④ 副本同步防线 — Kafka ISR 缩容与 unclean leader

交易所有多份账本副本(Partition Replica),主账本(Leader)宕机 → 从副本(Follower)接班。但同步滞后的从副本能接班吗?

生产事故案例:开启 unclean leader → 新主缺 100 条消息 → 业务对外付错款 → 关闭 unclean 后宁可停服也不丢数据。

四维联动(一次完整链路)

交易流程:交易员 T1 在 JVM 内修改共享库存(volatile 写 happens-before 后续读)→ Spring 注入 OrderService(三级缓存解决 OrderService/UserService 循环依赖)→ 业务执行 SQL UPDATE → MySQL 写 redo log PREPARE → 写 binlog → redo log COMMIT(两阶段提交崩溃可恢复)→ 同时把订单发 Kafka → ISR 3 副本同步 → Leader 宕机从 ISR 中选新主(不开 unclean 保数据)→ 全链路一致性保证。

跨文章衔接(7 处)


Java内存模型happens-before实战与Spring循环依赖源码与MySQL redo log恢复与Kafka ISR缩容追问精讲


上篇:happens-before实战场景

一、8大规则实战(结合代码理解)


规则1:程序顺序(单线程有序)
  int a = 1; int b = 2;
  → a写happens-before b写(但可重排,不影响结果)

规则2:volatile变量
  volatile boolean ready;
  // 线程A:data = 42; ready = true;
  // 线程B:if(ready) print(data); // 一定能看到data=42
  → ready写happens-before ready读→data(前面的)对B可见

规则3:监视器锁
  synchronized(obj) { x = 1; }
  // 线程A:synchronized(obj){x=1;}
  // 线程B:synchronized(obj){print(x);} // 看到1
  → unlock happens-before 后续lock

规则4:线程启动
  Thread t = new Thread(() -> print(shared)); // shared=42在start前
  shared = 42; t.start();
  → main的写(start前) happens-before 线程t内代码→看到42

规则5:线程join
  Thread t = new Thread(() -> result = compute());
  t.start(); t.join(); print(result);
  → 线程t的写 happens-before join后→看到result

规则8:传递性
  A happens-before B, B happens-before C → A happens-before C

二、追问链


Q1: 不加volatile/synchronized,多线程读写一定不可见吗?
A: 不一定(JMM不保证,但JVM/CPU可能恰好可见)。
   但你不该依赖"恰好可见"(不可移植/不可靠)。
   要保证可见→用volatile/synchronized/final。

Q2: final的happens-before怎么保证?
A: final字段写完后插StoreStore屏障。
   → 构造方法完成后final值对所有线程可见(安全发布)。
   所以final字段不需要volatile。

Q3: ThreadLocal需要happens-before吗?
A: 不需要(线程隔离,不共享)。
   每个线程有自己的ThreadLocal副本,不跨线程→无可见性问题。

中篇:MySQL redo log崩溃恢复

三、redo log核心(WAL机制)


WAL(Write-Ahead Logging) = 先写日志再写数据

为什么先写日志:
  ①数据页写磁盘随机IO(慢)→先不写
  ②把修改先记录到redo log(顺序IO,快)
  ③提交时redo log刷盘(fsync)
  ④数据页异步刷盘(Buffer Pool→磁盘,checkpoint)

崩溃恢复:
  MySQL重启→读redo log→重放未刷盘的修改→数据恢复
  → redo log保证已提交事务不丢(即使数据页没刷盘)

四、两阶段提交(redo + binlog一致)


事务提交流程(两阶段):
  1.Prepare:写redo log(prepare状态)
  2.Write binlog:写binlog
  3.Commit:写redo log(commit状态)

崩溃恢复判断:
  redo log有prepare但无commit:
    → 检查binlog是否完整
    → binlog完整:提交(两阶段到binlog就算成功)
    → binlog不完整:回滚(事务没完成)

→ 保证redo和binlog一致(主从复制/恢复都正确)

追问链


Q1: redo log和binlog都要写,性能不会差吗?
A: redo log顺序写(快),binlog也是顺序追加(快)。
   两者都是顺序IO(比数据页随机IO快很多)。
   fsync策略(innodb_flush_log_at_trx_commit)控制刷盘频率:
   0=不刷(OS控制)/1=每次提交刷(最安全)/2=每次写OS buffer(每秒刷)

Q2: innodb_flush_log_at_trx_commit设什么?
A: 1=每次提交fsync(最安全,性能略差)→生产推荐
   2=每次写OS buffer(最多丢1秒)→性能好
   0=OS控制(最不安全)→不推荐
   金融:1(不丢数据)。互联网高并发:可接受2(少量丢)。

Q3: redo log满了怎么办?
A: redo log是固定大小的环形文件。
   写到末尾→从头覆盖→覆盖前要确保对应数据页已刷盘(checkpoint推进)。
   如果redo log满→强行刷数据页(阻塞)→性能骤降。
   → redo log大小要够(innodb_log_file_size,建议1-4GB)。

下篇:Kafka ISR缩容与unclean leader

五、ISR管理(复习+深挖)


ISR(In-Sync Replicas) = 与Leader同步的副本集合

进入ISR条件:
  副本的fetch请求延迟 < replica.lag.time.max.ms(默认10秒)

被踢出ISR:
  超过10秒没同步→从ISR移除
  → 移除后该副本数据落后(可能不完整)

六、unclean leader选举(高频)


场景:所有ISR副本都挂了(只剩非ISR副本)
  → 要不要让非ISR副本当Leader?

unclean.leader.election.enable=false(默认,推荐):
  → 不让非ISR当Leader→分区不可用(等ISR恢复)
  → 数据安全(不丢),但牺牲可用性

unclean.leader.election.enable=true:
  → 让非ISR当Leader→分区可用
  → 但非ISR数据不完整→丢失数据(覆盖)
  → 牺牲数据安全换可用性

追问:
  Q1: ISR缩容怎么发生?
  A: 副本同步慢(网络/磁盘IO/GC)→超过replica.lag.time.max.ms→从ISR移除。
     如果Leader在ISR→移除其他。如果Leader挂了→ISR里的选新Leader。

  Q2: ISR为空怎么办?
  A: ①false:分区不可用(读写都失败),等ISR恢复(网络恢复/重启)。
     ②true:选非ISR当Leader(有数据丢失风险)。
     生产推荐false(不丢数据>可用性)。

  Q3: 怎么减少ISR缩容?
  A: ①replica.lag.time.max.ms调大(给慢副本更多时间);
     ②副本网络/磁盘要好(不慢);
     ③JVM GC别太频繁(STW影响同步);
     ④replication.factor=3(有冗余,一个挂了还有2个ISR)。

  Q4: ISR和HW(高水位)什么关系?
  A: HW=min(所有ISR副本的LEO)。
     ISR缩小→副本少了→HW可能变化(不前进)。
     ISR扩大→HW可能前进(同步恢复了)。

真题来源


相关页面


🚀 下一篇

下一篇:Java内存泄漏排查与Spring DevTools与MySQL Undo Log与Redis Cluster扩缩容追问精讲(L4 · Day 4-14 · 综合 8)

为什么接下来学 this:

本文讲透了 happens-before + Spring 三级缓存 + MySQL redo log + Kafka ISR 缩容 四大一致性内核,但 L4 综合追问仍在继续——下一篇追问 故障排查 + 框架工具 + 数据库回滚 + 缓存集群扩缩 四大方向:Java 内存泄漏排查(jmap/MAT/GC Roots 引用链)+ Spring DevTools 热部署(双 ClassLoader 机制)+ MySQL Undo Log MVCC 回滚(与本文 redo log 形成双向恢复对偶)+ Redis Cluster 扩缩容(槽位迁移 + ASK/MOVED 重定向)。

衔接要点(学完本文你已经掌握):

回链导航:学习路径地图 · Java内存模型JMM与volatile深度实战 · Spring源码原理与企业级应用


本文是 L4 阶段综合追问的第 7 篇,把 JMM/Spring/MySQL/Kafka 四大一致性内核机制串成「内存可见性 + Bean 注入 + 事务持久化 + 副本一致」的故事。学完本文,你应该能在面试现场白板手画 Spring 三级缓存 A/B 循环依赖流程 + MySQL WAL 两阶段提交时间线 + Kafka ISR 缩容决策树 + happens-before 8 大规则代码示例——这是 25K+ Java 架构师的核心能力。下一篇 L4-14 综合追问 8 继续内存泄漏/DevTools/undo log/Redis Cluster 扩缩容方向。