罗罗编程学习记录
本页内容 展开查看

01.5.3 内存模型与内存序

所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.5 计算机组成与体系结构

覆盖范围

  • 强内存模型与弱内存模型的区别
  • Store/Load 屏障与 acquire/release 语义
  • x86 TSO、ARM/弱模型的可重排范围
  • 编译器重排与 CPU 重排
  • 典型代码案例与无锁编程正确性

高频题速览

编号 题目 难度 频率
01.5.3-001 什么是内存模型 进阶 ★★★★★
01.5.3-002 强模型和弱模型差在哪 高级 ★★★★★
01.5.3-003 acquire/release 语义是什么 高级 ★★★★★
01.5.3-004 store-load 屏障为什么需要 高级 ★★★★☆
01.5.3-005 编译器重排和 CPU 重排有什么区别 进阶 ★★★★★
01.5.3-006 为什么要 volatile 进阶 ★★★★★
01.5.3-007 双重检查锁为什么需要内存序 高级 ★★★★★
01.5.3-008 x86 TSO 允许哪些重排 高级 ★★★★☆

01.5.3-001 什么是内存模型?

一句话结论

内存模型规定了一个 CPU(或编译器)对内存的读写操作在多核之间、以及在观测者眼中允许呈现什么顺序;它是硬件架构与编程语言共同约定的"重排契约",决定无锁代码怎样才正确。

概念解释

  • 硬件内存模型:CPU 允许哪些指令在多核间重排(如 x86 TSO、ARM 弱模型)。
  • 编程语言内存模型:C++/Java/Go 规定编译器与运行时可做哪些重排,以及原子操作的可见性顺序。
  • 目的:给编译器和 CPU 留出优化空间,同时给程序员一个"可依赖的顺序保证"。

原理流程

  1. 单线程内:程序顺序对自己不变(as-if-if)。
  2. 多核间:A 核的写操作何时对 B 核可见、按什么顺序可见,由模型约定。
  3. 程序员用原子操作/屏障显式声明关键顺序。

代码或图示

A 核:x=1; flag=1;
B 核:while(flag==0); assert(x==1);
内存模型决定:B 看到 flag==1 时,能否保证看到 x==1

常见误区

  • 以为程序顺序就是执行顺序:编译器和 CPU 都会重排,单线程看不出,多线程暴露问题。
  • 以为内存模型只是 CPU 的事:编程语言内存模型(如 C++ memory_order)才是代码直接依赖的契约。

追问

  • 为什么要有内存模型?答:不约定顺序,CPU 为性能可任意重排,无锁程序无法写对;约定后优化与正确性可兼顾。
  • 内存模型和缓存一致性关系?答:MESI 保证同一地址副本一致;内存模型约定多地址操作的可见顺序,二者见 01.5.2。

01.5.3-002 强内存模型和弱内存模型差在哪?

一句话结论

强模型(如 x86 TSO)只允许少数重排(典型为 store-load 重排),程序员少用屏障也能写对;弱模型(如 ARM、RISC-V、PowerPC)允许更多重排(store-store、load-load、load-store 都可能),必须显式插入屏障才能保证可见顺序。

概念解释

  • TSO(Total Store Order):x86 采用,所有核看到的 store 顺序一致;唯一常见重排是 store 后面跟 load(store buffer 导致 load 越过旧 store)。
  • 弱模型:store 与 store、load 与 load 之间都可能重排,单核看到的顺序和多核看到的不同。
  • 代价:弱模型重排自由度大,CPU 流水线更高效,但无锁代码复杂。

原理流程

  1. 强模型:默认大部分顺序自动保证。
  2. 弱模型:关键路径必须显式 acquire/release/fence。
  3. 跨架构移植:在 x86 上跑对的无锁代码,到 ARM 上可能出错,因为屏障缺失。

代码或图示

x86 TSO 允许:load 越过前面的 store(store buffer 作用)
ARM 弱模型:store-store、load-load 都可能重排

常见误区

  • 以为 x86 上跑对的无锁代码在 ARM 上也一定对:x86 隐式屏障多,ARM 需要显式,移植必须复查内存序。
  • 以为弱模型就是乱:它是有规则的弱,通过屏障精确控制关键路径。

追问

  • 为什么弱模型在移动设备流行?答:ARM 低功耗设计允许更激进的重排,换取能效;服务器 ARM 同样是弱模型。
  • C++ 的 memory_order_relaxed 对应什么?答:只保证原子性不保证顺序,用在计数器等不依赖顺序的场景。

01.5.3-003 acquire/release 语义是什么?

一句话结论

release 操作(写)之前的所有内存访问,在该 release 对其他核可见时一定已经完成;acquire 操作(读)之后的所有内存访问,在该 acquire 读到 release 写入的值之后才开始执行;二者配对形成"释放-获取"同步。

概念解释

  • release:像一个出口,前面的写不许越过它排到后面。
  • acquire:像一个入口,后面的读写不许越过它排到前面。
  • 配对:B 核 acquire 读到 A 核 release 写的值,A 在 release 之前的所有写,对 B 都可见。

原理流程

  1. A 构造数据后写标志位(release)。
  2. B 读标志位(acquire),读到值后才访问数据。
  3. 语义保证:B 看到标志位时,A 的数据一定已经写好。

代码或图示

A:data = 42;
   flag.store(1, release);     // data 不许排到这之后
B:while (flag.load(acquire) == 0);
   assert(data == 42);           // 后面访问不许排到这之前

常见误区

  • 以为 acquire/release 是全屏障:它们只约束配对方向,比 seq_cst 宽松、性能更好。
  • 以为两个方向都要显式屏障:release 在写侧、acquire在读侧,分别约束,不要混。

追问

  • seq_cst 比 acquire/release 多什么?答:全局顺序一致性,所有核看到的 seq_cst 操作顺序一致;更严格但更慢。
  • Java 的 volatile 对应什么?答:volatile 写相当于 release,读相当于 acquire,synchronized 更严格。

01.5.3-004 store-load 屏障为什么需要?

一句话结论

store-load 重排是指:核 A 先写 X 再读 Y,多核观测中 A 的读 Y 可能排在写 X 前面;因为 store 先进入 store buffer 还没真正写到 cache,A 不等它完成就去读 Y。要消除这种重排,需要 store-store 与 load-load 之间的全屏障(如 x86 mfence,C++ memory_order_seq_cst)。

概念解释

  • 现象:A 写 X=1,接着读 Y;由于 X 在 store buffer,A 读 Y 时 X 还没对其他核可见。
  • 后果: Dekker 算法这类"双方各写后读对方变量"的经典同步会失效。
  • 解决方案:全屏障(mfence/lock 前缀指令),保证 store 先全局可见后才允许后续 load。

原理流程

  1. A 写 X 进 store buffer。
  2. A 读 Y,直接命中 cache(不等 X 落地)。
  3. B 写 Y 后读 X,可能读到旧值,双方互相等待。

代码或图示

A: X=1;  r1=Y;
B: Y=1;  r2=X;
TSO 下 r1 与 r2 可能都读到 0(store-load 重排)
修正:在 X=1 后插入全屏障,再读 Y

常见误区

  • 以为 acquire/release 能解决 store-load 问题:它们不约束写后读,必须 seq_cst 或显式全屏障。
  • 以为 x86 TSO 没有重排:store-load 重排正是 TSO 唯一常见允许项。

追问

  • x86 用什么指令做全屏障?答:mfence,或任何带 lock 前缀的指令(如 lock add)都具备屏障语义,具体以 Intel SDM 为准。
  • C++ 中 store-load 同步用什么?答:memory_order_seq_cst 对所有原子操作,或显式 atomic_thread_fence(seq_cst)。

01.5.3-005 编译器重排和 CPU 重排有什么区别?

一句话结论

编译器重排发生在编译期,优化指令顺序(在单线程 as-if-if 等价前提下);CPU 重排发生在运行期,由乱序执行和 store buffer 造成;二者都要靠内存屏障同时抑制——只挡一个不够。

概念解释

  • 编译器重排:优化器在生成指令时交换读写顺序,可能把变量读到寄存器反复用。
  • CPU 重排:流水线乱序、store buffer、缓存一致性导致实际执行/可见顺序与程序序不同。
  • 屏障作用:volatile/原子语义告诉编译器"不许重排这段",内存屏障指令告诉 CPU "不许越过这里"。

原理流程

  1. 编译期:优化器按单线程等价重排。
  2. 运行期:CPU 动态重排。
  3. 代码要同时挡住两层:高级语言内存序同时控制编译器与 CPU。

代码或图示

编译器:a=1; b=2;   → 可能生成 b=2; a=1;(单线程无差异)
CPU:   a=1; b=2;   → store buffer 让 b 先对其他核可见
屏障:  原子写 release → 编译器不越过 + CPU 发屏障指令

常见误区

  • 以为加了 volatile 就够挡 CPU:volatile 在 C/C++ 里主要挡编译器优化,CPU 重排要靠原子操作/屏障。
  • 以为运行期没乱序就没事:编译器已经把代码重排过,CPU 再按重排后的顺序跑,问题依旧。

追问

  • 为什么 volatile 在 Java 里既能挡编译器又挡 CPU?答:Java 内存模型把 volatile 定义为 acquire/release 语义,编译器与 JIT 都遵守,底层插入必要屏障。
  • 怎么验证编译器重排?答:看汇编(objdump/godbolt)比较优化前后指令顺序,具体随编译器版本。

01.5.3-006 为什么要 volatile?它解决什么问题?

一句话结论

volatile 告诉编译器该变量可能被外部(硬件、其他线程、信号)改变,不许把它缓存到寄存器、不许优化掉读写;在 C/C++ 中它主要挡编译器优化,不保证多核原子性与可见性,多核同步要用原子操作。

概念解释

  • 挡优化:编译器不得把多次读合并成一次、不得把死存储删掉。
  • C/C++ 局限:不保证原子性,不保证内存序。
  • Java/C#:volatile 有 acquire/release 语义,可见性与顺序都有保证。

原理流程

  1. 编译器看到普通变量,可能把它读到寄存器反复使用。
  2. volatile 强制每次从内存读。
  3. 多核同步仍需 std::atomic 或锁。

代码或图示

volatile int flag;
// 单核信号处理中可用;多核无锁场景应改用
std::atomic<int> flag;  // 有原子性 + 内存序

常见误区

  • 以为 C 里 volatile 就能做无锁计数器:它不保证 flag++ 原子,多线程会丢更新。
  • 以为 Java volatile 能替代锁:它保证可见性但不保证复合操作原子性(i++ 仍要锁)。

追问

  • 什么时候只用 volatile 就够?答:单核下与硬件寄存器、信号处理共享变量;Java 中一个线程写、多个线程读的状态标志。
  • 为什么无锁队列必须用 atomic 而不是 volatile?答:CAS 操作需要硬件原子指令,volatile 不提供。

01.5.3-007 双重检查锁(DCL)为什么需要内存序?

一句话结论

DCL 在无锁路径下读单例引用,再判空加锁;问题在于构造对象时"分配内存 → 赋值字段 → 把引用指向对象"可能被重排,导致另一线程读到非 null 但字段未初始化的半成品对象;必须用 release/acquire 或 volatile 约束顺序。

概念解释

  • 重排:JIT/CPU 可能把 instance = new Instance() 拆为:分配内存、instance 指向内存、再构造字段;另一线程看到 instance 非空就使用,字段却还没填。
  • 修复:发布方用 release 写,接收方用 acquire 读,保证字段先于引用可见。
  • Java:volatile 字段恰好提供该顺序保证。

原理流程

  1. 线程 A:加锁、构造对象、release 写 instance。
  2. 线程 B:先无锁读 instance,acquire 读到非空,使用对象。
  3. 语义保证:B 看到 instance 时,A 的构造已完成。

代码或图示

// 错误:instance 未 volatile,构造可能被重排
if (instance == null) {
    synchronized (lock) {
        if (instance == null) instance = new Instance();
    }
}
// 正确:instance 为 volatile(或 release/acquire 写读)

常见误区

  • 以为加了 synchronized 就够:无锁路径的第一次读没有锁保护,仍可能读到半成品。
  • 以为 DCL 是性能优化首选:现代 JVM 中静态 holder 枚举/静态初始化更简单可靠,DCL 只是历史经典考点。

追问

  • C++11 以后怎么写 DCL?答:用 std::atomic<Instance*> 配合 memory_order_acquire/release,或直接用局部静态变量(线程安全 static 初始化)。
  • 为什么静态局部变量初始化是线程安全的?答:C++11 起标准规定局部 static 初始化线程安全,编译器内置栅栏。

01.5.3-008 x86 TSO 允许哪些重排?哪些不允许?

一句话结论

x86(TSO)保证:load-load 不重排、store-store 不重排、load-store 不重排(store 后 load 是唯一例外);也就是说除了"store 后面跟 load"可能被 store buffer 拆开,其他顺序都对程序员可见。

概念解释

  • 不允许重排:读-读、写-写、读-写(load 后 store)。
  • 允许重排:写-读(store 后 load),因为 store 先进 buffer,CPU 不等它落地就执行后面的 load。
  • 实际后果:Dekker 同步在 x86 上仍需全屏障,其他场景通常隐式够用。

原理流程

  1. A 写 X 进 store buffer。
  2. A 读 Y,直接命中 cache,不等 X 落地。
  3. B 同时写 Y 后读 X,双方都可能读到对方写之前的值。

代码或图示

不重排:L1 L2   S1 S2   L1 S2
允许:  S1 L2 (store buffer)

常见误区

  • 以为 x86 是完全顺序模型:store-load 重排是真实存在的,Dekker 类算法需要 mfence。
  • 以为 x86 的原子指令自带全屏障:带 lock 前缀的指令同时是内存屏障。

追问

  • Linux 内核里 smp_mb() 在 x86 上展开成什么?答:通常是 mfence 或锁前缀指令,具体实现随内核版本待确认。
  • 为什么 x86 还能保持高性能?答:乱序执行在单核内不受 TSO 限制,TSO 只约束多核可见顺序,性能损失有限。

01.5.3-009 Go 的 channel 和 mutex 用了什么内存序?

一句话结论

Go 的 sync.Mutex、channel 操作底层用原子操作和内存屏障实现 acquire/release 语义;Go 内存模型保证 happens-before(发送 happens-before 接收完成、解锁 happens-before 加锁),程序员不直接写 memory_order。

概念解释

  • Go 内存模型:基于 happens-before 关系。
  • channel:发送 happens-before 接收完成。
  • mutex:Unlock happens-before 下一次 Lock。

原理流程

  1. Go runtime 底层用原子操作。
  2. 编译器和 runtime 保证 happens-before。
  3. 程序员用 channel/mutex 即可,不用手写屏障。

代码或图示

// 发送 happens-before 接收
ch <- data          // 发送
x := <-ch           // 接收,data 的写入对 x 可见

常见误区

  • 以为 Go 不需要内存序:它在 runtime 内部实现,程序员靠 channel/mutex 建立顺序。
  • 以为无锁 channel 不需要同步:channel 本身就是同步机制。

追问

  • Go 的 atomic 包?答:提供 atomic.Load/Store,有顺序选项,高级用法才用。
  • Java 的 volatile 和 Go 变量?答:Go 没有 volatile,同步靠 channel/mutex/atomic。

待整理清单

  • [ ] C++ 各 memory_order 场景对照表
  • [ ] ARMv8/ARMv9 屏障指令(dmb/ldar/star)细节
  • [ ] RISC-V 内存模型与 fence 指令
  • [ ] JVM 内存模型(JMM)与 volatile 的真实实现差异