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 留出优化空间,同时给程序员一个"可依赖的顺序保证"。
原理流程
- 单线程内:程序顺序对自己不变(as-if-if)。
- 多核间:A 核的写操作何时对 B 核可见、按什么顺序可见,由模型约定。
- 程序员用原子操作/屏障显式声明关键顺序。
代码或图示
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 流水线更高效,但无锁代码复杂。
原理流程
- 强模型:默认大部分顺序自动保证。
- 弱模型:关键路径必须显式 acquire/release/fence。
- 跨架构移植:在 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 都可见。
原理流程
- A 构造数据后写标志位(release)。
- B 读标志位(acquire),读到值后才访问数据。
- 语义保证: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。
原理流程
- A 写 X 进 store buffer。
- A 读 Y,直接命中 cache(不等 X 落地)。
- 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 "不许越过这里"。
原理流程
- 编译期:优化器按单线程等价重排。
- 运行期:CPU 动态重排。
- 代码要同时挡住两层:高级语言内存序同时控制编译器与 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 语义,可见性与顺序都有保证。
原理流程
- 编译器看到普通变量,可能把它读到寄存器反复使用。
- volatile 强制每次从内存读。
- 多核同步仍需
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字段恰好提供该顺序保证。
原理流程
- 线程 A:加锁、构造对象、release 写 instance。
- 线程 B:先无锁读 instance,acquire 读到非空,使用对象。
- 语义保证: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 上仍需全屏障,其他场景通常隐式够用。
原理流程
- A 写 X 进 store buffer。
- A 读 Y,直接命中 cache,不等 X 落地。
- 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。
原理流程
- Go runtime 底层用原子操作。
- 编译器和 runtime 保证 happens-before。
- 程序员用 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 的真实实现差异