内存一致性、原子操作与乱序执行基础

• 理解 release 语义
• 理解完整 fence 语义
• 理解开销差异

acquire 语义约束"该操作之后的内存操作不能重排到它之前"（acquire 之后的操作不能被重排到 acquire 之前），只约束一侧；release 语义约束"该操作之前的内存操作不能重排到它之后"（release 之前的操作不能下移到 release 之后），也只约束一侧。完整 memory fence（全屏障）约束两侧：既阻止之后的操作上移，也阻止之前的操作下移，即全序屏障。开销差异：acquire/release 是"单向"半屏障，只在需要的一侧施加约束，硬件只需在该侧插入屏障，重排自由度更大、开销更低；完整 fence 是双向全屏障，约束更严格，硬件需更强的序列化，开销更高。因此 acquire/release 因只约束一侧而更便宜，且能表达正确的同步语义。

acquire 只约束"之后不重排到之前"，release 只约束"之前不重排到之后"，各是一侧。完整 fence 两侧都约束。开销随约束强度增大，acquire/release 更便宜。

• 理解 TSO 模型
• 理解 load-load 重排
• 理解与弱内存区别

TSO（Total Store Order，x86 的内存模型）允许 store-load 重排（store 后 load 可被重排，因 store buffer 延迟），但 TSO 不允许 store-store 重排（两个 store 顺序保持）与 load-load 重排（两个 load 顺序保持）。原因：TSO 中 store 通过 store buffer 按序提交，load 直接读，store-store 与 load-load 保持顺序。弱内存平台（ARM、RISC-V 的 weak memory model）则允许更多重排：store-store、load-load、load-store、store-load 都可能被重排（除非使用屏障）。区别：TSO 只允许 store-load 一种重排，弱内存允许更多重排组合。因此 TSO 代码移植到弱内存平台需要更多屏障，而弱内存代码在 TSO 上可能 过度保守。

TSO 只允许 store-load 重排（store buffer 原因），而 store-store、load-load 保持顺序。弱内存允许多种重排。理解平台模型决定屏障需求。

• 理解 MESI 一致性
• 理解多地址顺序
• 理解内存顺序约束

缓存一致性协议（MESI）保证"单个内存地址"的读写一致性：所有处理器对同一地址看到一致的写入值（通过缓存行失效/共享维护）。但一致性协议不保证"多地址之间的可观察顺序"：两个处理器对不同地址的写入，另一个处理器可能观察到不同的顺序（如 A 写地址1、B 写地址2，观察者可能先看到地址2 再看到地址1）。因为各处理器通过 store buffer、缓存行失效延迟等，使不同地址的写入传播顺序不确定。因此需要内存顺序约束（memory ordering / fence）来保证多地址之间的可观察顺序。单地址一致解决"同一地址两次读是否一致"，内存顺序解决"不同地址的先后可观察"，两者层面不同。

MESI 保证单地址一致，但多地址顺序由 store buffer/失效延迟引入乱序。内存顺序约束（屏障）保证多地址可观察顺序。两者问题层面不同。

• 理解数据冒险
• 理解控制冒险
• 理解缓解手段

结构冒险（structural hazard）：硬件资源冲突，如两条指令同时需要同一硬件单元（ALU、同一寄存器端口、同一内存端口），由于资源不足。缓解：硬件资源重复（多端口、多 ALU）、流水线插入气泡。数据冒险（data hazard）：指令间数据依赖，如一条指令需要上一条的结果（RAW 读后写、WAR 写后读、WAW 写后写）。缓解：转发（forwarding/bypassing）、编译器重排（调度）、插入气泡（stall）。控制冒险（control hazard）：分支指令改变流向，流水线已取指/译码的指令可能错误。缓解：分支预测、分支延迟槽、预测失败时冲刷流水线。三类冒险分别由资源、数据依赖、控制流不确定引起。

结构冒险=资源冲突，数据冒险=数据依赖，控制冒险=分支不确定。缓解：资源重复、转发/调度、分支预测。理解三类冒险与缓解是流水线设计核心。

• 理解 Tomasulo 算法
• 理解 WAR/WAW 假依赖
• 理解保留站

Tomasulo 算法通过保留站（reservation station）与寄存器重命名（register renaming）实现乱序执行。寄存器重命名把架构寄存器映射到更多物理寄存器：当指令要写一个寄存器时，分配一个新的物理寄存器，而不是直接覆盖旧值，从而打破 WAR（写后读，旧指令需读旧值）与 WAW（写后写，两条指令写同一寄存器）的假依赖（名字依赖）。保留站（RS）缓存未发射指令的操作数，跟踪操作数就绪状态，操作数就绪即发射。核心思想：用"数值状态"而非"寄存器名"传递依赖，通过物理寄存器重命名消除名字相关（WAR/WAW），只保留真正的数据依赖（RAW），从而释放指令级并行。

Tomasulo 核心是"寄存器重命名消除名字相关 + 保留站跟踪数据就绪"。重命名把 WAR/WAW 变成无关的独立指令，只保留 RAW 真依赖。这是乱序执行的基石。

• 理解物理寄存器池
• 理解映射表
• 理解释放并行

寄存器重命名维护一个架构寄存器到物理寄存器的映射表（RAT）。当指令写一个架构寄存器时，分配一个空闲物理寄存器，并把映射更新到新物理寄存器；旧物理寄存器在无引用后回收。这样相同架构寄存器名在不同时刻可对应不同物理寄存器，同一架构寄存器的多个写操作（来自不同指令）分别写到不同物理寄存器，互不冲突，打破 WAR/WAW 名字依赖。物理寄存器池比架构寄存器多得多（如 32 个架构寄存器映射到 224 个物理寄存器），由重命名单元分配。效果：指令间只要无真实数据依赖（RAW）就可乱序执行，释放指令级并行（ILP），处理器可同时执行多条读写同一架构寄存器的指令。

重命名把"名字冲突"（WAR/WAW）通过物理寄存器池化解，使指令只受 RAW 真依赖约束。物理寄存器池大是释放 ILP 的关键。

• 理解流水线冲刷
• 理解预测错误代价
• 理解级数深度影响

分支预测失败时，已经取指/译码的指令是沿错误路径（预测方向）取的，可能执行错误分支的指令，必须全部冲刷（flush/purge）并从正确分支重新取指，以保证程序正确性。冲刷的对象是流水线中已取指、译码、可能出现于执行的指令（含部分执行结果要回滚）。代价理解：流水线级数越深，预测失败时需冲刷的指令越多（已进入流水线的指令数约等于级数），浪费的取指/译码/执行周期越多，因此代价越大。也是深流水线需更精确分支预测的原因（预测错误成本随级数增长）。代价 ≈ 级数 × 每条指令的周期。

预测失败冲刷错误路径指令，重取正确分支。级数越深，冲刷指令越多、浪费周期越多，代价越大。这解释了深流水线依赖高精度分支预测。

• 理解顺序提交
• 理解 ROB
• 理解精确异常

乱序执行中指令按完成顺序执行，但需按程序顺序确认结果。重排序缓冲（ROB）按程序顺序登记所有指令，指令乱序完成后，在 ROB 中按程序顺序依次提交（commit），提交时才更新架构状态（写寄存器、内存）。精确异常（precise exception）：异常发生时，ROB 中已提交的指令状态确定，未提交的指令被丢弃。处理器在 ROB 中找到触发异常的指令，之前已提交的指令状态保留（程序状态在此指令处一致），之后未提交的指令回滚，从而保证异常时处理器状态与程序顺序一致（精确）。这样乱序执行不影响异常语义，异常处状态精确到指定指令。

ROB 保证"乱序执行、顺序提交"。提交时更新架构状态，异常时丢弃未提交指令、保留已提交状态，实现精确异常。这是乱序执行正确性的关键。

• 理解内存访问顺序
• 理解 store-to-load 转发
• 理解别名检测

load 队列与 store 队列记录已发射/执行的 load/store 指令，维护内存访问顺序。乱序执行中，load 可能先于之前的 store 执行，需检测别名（store 与 load 是否访问同一地址）以避免错误。store-to-load 转发：load 执行时，若之前的 store 已写入同一地址且数据尚未提交到内存/缓存，load 直接从 store 队列中转发该 store 的数据，避免等待 store 提交，降低延迟。维护顺序：load 队列检查是否有更早的 store 与之别名，store 队列决定何时可写回内存。若 load 发现更早的 store 但该 store 尚未完成，load 需等待或重放。转发实现了"load 看到最近 store 的值"，同时用别名检测保证顺序正确。

load/store 队列维护内存顺序（别名检测），forward 让 load 直接取未提交 store 的值，减少延迟。别名检测保证乱序 load 不破坏内存顺序语义。

• 理解动态分支预测
• 理解两级历史/TAGE
• 理解适用场景

静态分支预测在编译期/解码时做固定预测，不依赖运行时历史，如预测向后跳转（循环）为 taken、向前跳转为 not taken。简单、低开销、无历史表，但精度低，适用于简单处理器或预测器启动初期。动态分支预测利用运行时历史（分支历史寄存器、历史表）预测，精度高。两级历史预测（如 BHT + 分支历史）结合分支自身的局部历史与全局历史，捕捉相关模式；TAGE（Tagged Geometric History Length）用不同长度的历史做几何级预测器组合，通过 tag 选择最合适的预测器，是现代高性能处理器的精度最佳预测器。适用场景：静态预测适合简单/低功耗/低延时场景，动态预测（TAGE）适合高性能处理器（需要高精度以抵消深流水线冲刷代价）。

静态预测简单低精度、零历史开销；动态预测（两级/TAGE）高精度、有历史表开销。高性能处理器用 TAGE 等动态预测，简单/嵌入式用静态。取舍是精度与开销。

• 理解取指带宽
• 理解分支预测精度限制
• 理解瓶颈

更宽的发射宽度（每周期发射更多指令）可提升指令级并行（ILP），提高吞吐，是处理器性能提升的途径。但受限于：1) 取指带宽：每周期需取出足够多指令供发射，取指带宽不足则发射单元空闲；2) 分支预测精度：预测错误时冲刷流水线，宽发射（深流水线）冲刷代价更大，预测精度不足反而降低吞吐；3) 依赖与资源限制：指令间依赖、寄存器/ROB 资源限制实际并行度。因此一味加宽发射宽度若无配套的取指带宽、分支预测精度、解码能力，收益递减甚至受限于这些瓶颈。现代处理器在发射宽度、取指、预测、重命名资源间协同平衡。

宽发射需取指带宽供给、分支预测精度支撑。若取指不够或预测不准，发射单元空转或被冲刷。性能受最短木板约束，需多方协同。

• 理解 seq_cst
• 理解 ARM 实现
• 理解开销来源

seq_cst（顺序一致）要求存在一个全局一致的执行顺序，所有线程看到同一顺序。x86 是 TSO，允许 store-load 重排，而 seq_cst 要求 store 后不能有 load 被观察到重排（store 要全局可见在线程后续 load 之前）。因此 x86 的 seq_cst store 常需用 xchg（原子交换，隐含 lock/full barrier）或 mfence（full fence）来阻止 store-load 重排并使其立即全局可见，否则无法满足 seq_cst 的全局序。ARM 是弱内存，需显式屏障（如 dmb ish）施加全序，seq_cst store 需隐式屏障（编译为 load-acquire + store-release 组合或显式 dmb）。开销来自：x86 的 xchg/mfence 是 full barrier，序列化 store、阻止重排，代价高；ARM 的显式屏障（dmb）也序列化，成本高。seq_cst 比 acquire/release 贵，因为它要求全局对称的顺序约束。

seq_cst 要求全局序，x86 用 xchg/mfence 阻止 store-load 重排，ARM 用显式屏障。开销来自"全屏障/序列化"成本。seq_cst 最贵，比 acquire/release 多全局序约束。

• 理解 Dekker 算法
• 理解 store-load 重排
• 理解修复

Dekker 算法：线程 A 写 flag[A]=1，读 flag[B]；线程 B 写 flag[B]=1，读 flag[A]。若两者都不为 1 则进入临界区。无锁语义下，TSO 的 store-load 重排允许"store 后 load 被重排到 store 前面"，导致：A 的读 flag[B] 可能先于写 flag[A] 执行，B 的读 flag[A] 先于写 flag[B]，两者都读到 0，同时进入临界区。修复：需要阻止 store-load 重排，即用 seq_cst 的 store（x86 上 xchg/mfence）或 acquire/release 屏障，使标志写入对其他线程可见后在读之前。实际上 Dekker 需要 seq_cst 语义（或至少 full barrier）保证"写后读"的顺序。修复用 seq_cst 原子操作或显式 fence。

Dekker 失败源于 TSO 的 store-load 重排。修复需 seq_cst（阻止 store-load 重排）。这解释了为什么 Dekker 式同步需要更强的内存序。

• 理解 store-load 重排
• 理解 mfence/lock
• 理解无锁队列影响

x86 的 store 先写入 store buffer（不立即写缓存），后续 load 若命中旧缓存则直接读旧值，可能观察到"store 尚未生效"而 load 先完成，即 store-load 重排。store buffer 是重排根源。mfence（full fence）强制 store buffer 排空并顺序化两侧操作，lock 前缀（如 lock cmpxchg）隐含全屏障，阻止重排。对无锁队列（如 SPSC/MPSC 头尾更新）：生产者更新 head 后，若消费者用 relaxed 读 head，可能因 store-load 重排读到旧值，需用 release/acquire 或 seq_cst 保证 head 更新的发布与读取顺序。head/tail 更新需正确的内存序（release 存、acquire 读）避免 store-load 重排破坏队列可见性。

store buffer 引起 store-load 重排，mfence/lock 强制顺序。无锁队列的 head/tail 需 release/acquire 或 seq_cst 保证顺序，避免读到旧 head/tail。

• 理解六种 memory_order
• 理解强弱关系
• 理解 seq_cst 开销

C11/C++11 的 memory_order：relaxed 无约束（允许任意重排，仅原子性）；acquire 约束"之后的操作不能重排到它之前"（load 用）；release 约束"之前的操作不能重排到它之后"（store 用）；acq_rel 是 acquire+release 组合（RMW 用）；seq_cst 是全序约束（所有 seq_cst 操作存在全局一致顺序，同时约束两侧）。强弱关系：relaxed < acquire/release < acq_rel < seq_cst。约束重排：relaxed 不约束；acquire 只约束一侧（load 后不重排到前）；release 只约束一侧（store 前不重排到后）；seq_cst 双向全序且要求全局一致。seq_cst 最贵因为要求全局一致顺序（所有线程看到同一序），x86 需 xchg/mfence、ARM 需隐式屏障，完全序列化，开销最大。

强弱关系 relaxed<acquire/release<acq_rel<seq_cst。seq_cst 要求全局一致序，实施强序列化，开销最大。acquire/release 单向约束，较便宜。

• 理解 memory_order_consume
• 理解编译器保守处理
• 理解降级原因

memory_order_consume 是 acquire 的"轻量"版本：它只保证"依赖该 load 的后续操作"有序（即通过数据依赖链传递），不要求该 load 后所有操作都排序，因此理论上只需对依赖链做排序，比 acquire 更便宜（硬件可只跟踪依赖）。但实现中多数编译器把 consume 降级为 acquire：因为正确地传递依赖链（consume 的线性化语义）在编译器层面很难精确实现（需识别所有依赖关系，避免误优化），且 C++ 标准对 consume 的可移植实现要求复杂。编译器保守地采用 acquire 语义（更严格但安全），牺牲了 consume 的理论性能优势。因此 consume 虽理论更便宜，实际被降级为 acquire，无性能优势。

consume 只排序依赖链，理论便宜；但编译器难以精确实现依赖链传递，保守降级为 acquire（更严格）。实际无性能收益，故多数用 acquire 替代。

• 理解编译屏障
• 理解 store-release
• 理解发布新版本

RCU 读侧只需"编译屏障或轻量读屏障"的原因：读侧读取的是指针（无锁），且读侧不写共享数据，只要保证"读指针的指针自身有序"与"因指针读到后，指针指向数据的初始化可见"即可。读侧不做写操作，因此只需编译屏障（保证编译器不重排读）或轻量屏障（保证指针读取顺序），无需 full barrier。写侧发布新版本：写侧先完整初始化新数据（写所有字段），然后用 store-release 发布指针（存指针），release 保证"指针之前的初始化写"不被重排到指针存之后，读者用 acquire 读指针后，reacquire 保证看到指针前的完整初始化。这样读者看到的新指针必然伴其完整初始化数据。

RCU 读侧只读，无需 full barrier，编译屏障足够（无写）。写侧 store-release 保证初始化先于指针发布，读者 acquire 看到完整初始化。这是 RCU"读多写少"优化的关键。

• 理解撕裂读写
• 理解原子性
• 理解对齐保证

撕裂读写（torn read/write）指对一个多字节对象（如 64 位）的访问，因并发写或非原子实现，读到部分旧值部分新值（或写入被拆成组件分别完成）。原因：若对象未对齐或跨缓存行，硬件无法保证单次原子访问，访问可能被拆成多个内存操作（如 32 位平台对 64 位）。即使对齐，若访问跨缓存行，缓存行独占失效可能使访问碎片化。C++ 原子类型（std::atomic）保证对齐：原子对象按自然对齐（如 atomic 对齐到 8 字节），不跨缓存行，且对支持的原子操作（如支持 lock-free 的）硬件提供原子指令（如 64 位原子读写），避免撕裂。若原子类型不支持 lock-free，则退化为锁，也保证原子性。因此对齐 + 原子指令避免撕裂。

撕裂源于非原子实现（未对齐/跨缓存行/位宽不足）。C++ 原子保证对齐 + 用原子指令（或锁）实现，避免撕裂。对齐是避免撕裂的基础。

• 理解 TSO 与弱内存
• 理解读者观察到不同顺序
• 理解重排类型

IRIW（Independent Read Independent Write）：两个写者分别写两个不同地址，两个读者分别读这两个地址。若两个读者观察到不同顺序（读者1 看到 A 先 B，读者2 看到 B 先 A），则说明不同写者地址的写入传播顺序不一致。TSO 下，四个处理器通过缓存一致性，写者按序传播，两个读者看到一致顺序（TSO 不允许这种不一致）。弱内存模型（如 ARM、RISC-V 的某些重排）允许写者之间的传播乱序，读者可能观察到不同顺序。因此 IRIW 能区分 TSO 与弱内存：弱内存允许"两个读者看到不同写入顺序"，这对应允许"写者地址间传播乱序"的重排（而非 store-load 重排）。TSO 对该场景保证一致，弱内存不保证。

IRIW 测试"多写者多读者是否观察到全局一致序"。TSO 保证，弱内存允许读者看到不同顺序（写者传播乱序）。这是区分模型的经典判据。

• 理解 FENCE 指令
• 理解 predecessor/successor
• 理解排序粒度

RISC-V 的 FENCE 指令带 predecessor 与 successor 参数，每个参数指定该 FENCE 排序的读写操作类型（I=输入/读，O=输出/写，R=读，W=写，组合如 IORW）。FENCE.pred, succ 表示：FENCE 保证 pred 中指定的内存操作（在 FENCE 之前）不会移动到 succ 中指定的内存操作（在 FENCE 之后）之后。通过选择 pred/succ 的 I/O/R/W 组合，可精确指定排序粒度：如 FENCE RW,RW 是全屏障（排序所有读写）；FENCE W,W 只排序写-写；FENCE R,R 只排序读-读。这样 FENCE 只在其需要的操作类型之间施加排序，未指定的操作类型不受约束，从而精细控制顺序约束，减少不必要的开销（比全屏障更宽松）。

FENCE 的 pred/succ IORW 参数精确指定"排序哪些操作类型"，实现按需屏障。全屏障 RW,RW 最严格，特定组合（如 W,W）更宽松、开销更低。

• 理解 RAW
• 理解 WAW
• 理解真依赖与假依赖

RAW（Read After Write，写后读）：后续指令读前序指令写的结果，是真实数据依赖（真依赖），必须保持顺序，不能重排。WAR（Write After Read，读后写）：后续指令写前序指令读的位置；WAW（Write After Write，写后写）：两条指令写同一位置。WAR 与 WAW 是名字相关（假依赖，name dependence）：它们不传递真实数据值，只是寄存器名/内存位置冲突。假依赖可通过寄存器重命名消除（WAR/WAW 用不同物理寄存器后变为无关），真依赖（RAW）无法消除，必须靠转发或等待。因此 RAW 是真依赖，WAR/WAW 是假依赖（可重命名消除）。

RAW 传递真实数据，是真依赖；WAR/WAW 只是名字冲突，是假依赖，可被寄存器重命名消除。区分真/假依赖决定能否乱序执行。

• 理解 RAW 冒险
• 理解气泡/stall
• 理解必须停顿的情况

转发（forwarding/bypassing）在结果产生时立即把值从执行单元"旁路"给需要它的指令，而不等结果写回寄存器（写回需一个周期），从而避免相邻指令因 RAW 冒险而停顿。相邻指令（如 add 后立即 add 用其结果）转发后无需插入气泡（stall），流水线连续。但仍必须停顿的情况：1) 从 load 转发（load-use）：load 从内存取数需要多个周期，结果在 load 周期后才就绪，紧邻的 load-use 无法转发，需停顿（或 load 延迟）；2) 转发路径不可达（如操作数需在更早阶段、跨级转发不可行）。因此 load-use 是最常见的必须停顿场景，需编译器调度或硬件停顿。

转发绕过写回直接给结果，解决 ALU 类 RAW。但 load-use（load 结果需多周期）无法转发，必须停顿。转发覆盖面有限，load 延迟是停顿主因。

• 理解 lock cmpxchg
• 理解虚假失败
• 理解无锁算法设计

x86 的 lock cmpxchg 是单条原子指令（lock 前缀）实现读改写，锁定总线/缓存行，保证原子，无虚假失败，简单可靠。ARM/RISC-V 的 LL/SC（Load-Linked/Store-Conditional）：LL 读地址并标记，SC 条件写，若地址在 LL 与 SC 之间被其他写修改则 SC 失败（返回失败标志）。SC 可能因虚假失败（spurious failure）失败——即使地址未被修改，也可能因异常、缓存行失效、上下文切换等失败。影响：无锁算法（如 CAS 循环）需用 SC 失败重试；虚假失败使循环可能多次重试（但最终成功），算法需容忍失败并重试，避免无限循环（需保证进展）。设计上无锁算法用 LL/SC 循环需处理虚假失败，相比 x86 CAS（无虚假失败）更复杂但更灵活（可构建任意原子操作）。

x86 CAS 原子无虚假失败，LL/SC 有虚假失败（需重试）。LL/SC 更灵活（可构建复杂原子操作），但需处理虚假失败、保证进展。这是无锁算法跨平台设计的差异。

• 理解 SPSC 队列
• 理解 acquire 读
• 理解 relaxed 风险

无锁 SPSC（单生产者单消费者）环形队列：生产者写入数据后，用 release 写发布 head 指针（head 更新），release 保证"head 之前的数据写入"不被重排到 head 之后，且对消费者可见；消费者用 acquire 读 head（acquire 保证读到 head 后，head 指向的数据写入对消费者可见）。这样生产者的数据写与 head 发布通过 release/acquire 配对，消费者看到 head 后必然看到完整数据。误用 relaxed：relaxed 不提供任何顺序保证，生产者的数据写可能被重排到 head 发布之后，或消费者读到 head 后看不到数据写（数据未发布），导致消费者读到未初始化/部分数据。relaxed 破坏"数据在 head 发布之前就绪"的可见性保证。因此 SPSC 必须用 release/acquire 保证数据可见性。

SPSC 用 release/acquire 配对，保证"head 发布前数据写可见"。relaxed 无此保证，可能读到未发布数据。可见性保证依赖 release/acquire 而非 relaxed。

• 理解 acquire/release
• 理解部分构造
• 理解内存序缺失

双重检查锁定（DCLP）：先不加锁检查指针，若为空则加锁并使用 volatile 指针赋值，避免每次加锁。但若无 acquire/release 或原子指针，可能观察到部分构造对象：构造新对象（写字段）与发布指针（存指针）之间，若没有 release 保证，编译器的重排或硬件的重排可能使指针先发布、对象字段后初始化，读者（acquire 读指针）看到指针非空但对象字段未初始化，读到部分构造对象。修复：用 std::atomic 指针，用 seq_cst 或 acquire/release 语义发布（store）与读取（load），保证"保存指针前对象完全初始化"（release 存）与"读指针后看到完整初始化"（acquire 读）。缺失时读者可能读到未初始化字段。

DCLP 需 release 发布指针（保证对象先初始化）、acquire 读指针（保证看到完整初始化）。缺失时重排使读者看到部分构造对象。这是经典内存序陷阱。

• 理解 lfence/sfence/mfence
• 理解 acquire/release 对应
• 理解重排约束

四类屏障：load-load 屏障禁止两个 load 之间的重排（load 后 load 不重排到前）；load-store 屏障禁止 load 与 store 重排（load 不被 store 越过）；store-load 屏障禁止 store 与 load 重排（store 不被 load 越过）；store-store 屏障禁止两个 store 重排。x86 的 lfence 是 load 屏障（load-load），sfence 是 store 屏障（store-store），mfence 是全屏障（所有）。对应关系：C++ acquire 语义约等于 load 后的屏障（load-load + load-store，即 acquire 之后操作不重排到 acquire 前），对应 lfence 组合；release 约等于 store 前的屏障（store-store + load-store，即 release 前操作不重排到 release 后），对应 sfence 组合。x86 上 acquire/release 常无需显式屏障（TSO 已保证 load-load/store-store），但 seq_cst 需 mfence。注意 store-load 屏障（x86 特有需求）不直接对应 acquire/release。

四类屏障分别禁止四类重排。lfence/sfence/mfence 对应 load/store/全屏障。acquire 对应 load 后屏障，release 对应 store 前屏障。x86 TSO 下部分重排天然禁止。

• 理解 relaxed 用途
• 理解计数器单调累加
• 理解控制依赖

relaxed 只保证原子性（单次读改写原子），不保证顺序。合法用途：无符号计数器的单调累加（如统计次数 close、引用计数初值递增），因为只需原子 +1，不依赖跨线程顺序，且累加语义不要求发布其他数据。边界：1) 发布指针（如发布一个指向数据的指针）：relaxed 不保证指针后的数据初始化可见，必须用 release 发布、acquire 读，否则读者可能看到未初始化数据；2) 控制依赖（如 if(load) 后访问其指向数据）：relaxed 不保证控制依赖的排序，可能读到未就绪数据，需升级 acquire/seq_cst。因此 relaxed 只适合"无数据发布、无控制依赖"的原子计数等场景，涉及发布/依赖必须升级内存序。

relaxed 只保证原子性。计数器单调累加无跨线程依赖，relaxed 可用；发布指针或有控制依赖需数据可见性，必须 upgrade 到 release/acquire。边界是"是否发布数据/依赖"。

• 理解缓存行独占
• 理解 ping-pong
• 理解延迟放大

原子 RMW（读改写）需在缓存行上执行原子操作，硬件要求该缓存行处于独占（MESI 的 M 或 E 状态），否则需先通过缓存一致性协议获得独占（失效其他副本）。RMW 在独占行上执行，保证原子。多线程争用同一原子变量：每个线程的 RMW 需轮流获得缓存行独占（锁行），导致缓存行在多个 CPU 间"乒乓"（ping-pong）：每次 RMW 都把行失效从其他 CPU 夺回，其他 CPU 下次 RMW 又需夺回，不断传播缓存行失效与重取。这放大延迟：每次 RMW 需等待缓存行在场（可能几十纳秒），高争用下大量核等待同一行，吞吐下降、延迟剧增。这是高争用原子操作的性能瓶颈（cache line contention）。

RMW 需独占缓存行，争用导致缓存行 ping-pong（行在 CPU 间来回失效重取），放大延迟。高争用原子变量是性能瓶颈，需减少争用（伪共享、分片）。

• 理解数据竞争 UB
• 理解破坏性优化
• 理解正确性

C/C++ 标准规定：并发读写同一非原子变量（无同步）构成数据竞争（data race），是未定义行为（UB），而非"只读到旧值"。因为编译器假设单线程（无数据竞争），可基于此做破坏性优化：1) 把变量缓存到寄存器，忽略内存（假设无其他线程写），导致重复读读到旧缓存值；2) 重排、合并、删除读写（如把变量读提升出循环、把写合并）；3) 假设变量不会被并发修改，推导出不变式（如读取后假设不变）。这些优化在单线程下正确，但在数据竞争下产生错误行为。由于是 UB，编译器甚至可假设不会发生，任意优化。因此必须用原子或同步，使行为定义，而非侥幸读到旧值。

数据竞争是 UB，编译器基于单线程假设做缓存、重排、合并等破坏性优化。正确做法是用原子/同步，而非依赖"读到旧值"的偶然行为。

• 理解 mutex 同步
• 理解 release/acquire
• 理解时间先后不足

happens-before（先行）关系通过同步操作建立：1) mutex：线程 A 解锁 mutex 与线程 B 加锁同一 mutex 建立 happens-before（A 解锁前的写对 B 加锁后可见）；2) atomic release/acquire：A 的 release 写与 B 的 acquire 读同一原子变量建立 happens-before；3) thread join：A create 线程并 join，join 建立 create 前写与子线程执行之间的 happens-before。仅靠时间先后（wall-clock 先后）不构成同步：因为编译器/硬件可重排，时间上先发生的写不保证对后读的线程可见（无同步则无可见性保证）。同步原语（mutex/atomic/join）建立 happens-before 才提供可见性保证。时间先后不提供跨线程可见性。

happens-before 由同步原语（mutex、release/acquire、join）建立，提供可见性保证。时间先后（无同步）不保证可见性，因为可重排。同步是"定义"的关系，时间顺序是"物理"的。

• 理解 TSO 与弱内存
• 理解推测执行
• 理解重排集合塑造

x86 采用 TSO（总存储序）因历史兼容：x86 长期沿用能够保持 store-store、load-load 顺序，仅允许 store-load 重排的顺序模型，软件依赖此模型。ARM/RISC-V 采用弱内存模型：允许更多重排（store-store、load-load、load-store、store-load 都可能），以换取更简单的实现与更高性能（硬件可更自由重排）。硬件机制塑造重排集合：写缓冲（store buffer）使 store 延迟、load 可能绕过未提交的 store（store-load 重排）；推测执行（speculation）使指令乱序执行，观测到重排；多核缓存失效延迟使写传播乱序。TSO 的写缓冲不重排 store-store，只允许 store-load；弱内存允许写缓冲与缓存失效造成更多重排。因此写缓冲与推测塑造了各模型允许的重排集合。

x86 历史原因选 TSO，ARM/RISC-V 为性能选弱内存。写缓冲/推测/缓存失效等硬件机制决定允许的重排集合。理解模型由硬件机制塑造。

• 理解 acquire/release 映射
• 理解编译器插入屏障
• 理解 DSB 额外保证

ARMv8 的 DMB（Data Memory Barrier）保证内存访问顺序（排序数据访问），DSB（Data Synchronization Barrier）更强，额外保证"屏障前的所有内存访问完成"且"后续指令等待屏障完成"（包括清空流水线、等待写缓冲排空）。与 C++ acquire/release 映射：acquire 约映射为 DMB（load 后），release 约映射为 DMB（store 前），在需要时编译器插入 DMB（例如 acquire 读/ release 写，或依赖弱序上下文）。编译器在需要排序的原子操作处插入屏障（如 seq_cst 用 DMB ISH，acquire/release 用对应 DMB）。DSB 相对 DMB 额外保证：DSB 同步执行（等待所有内存访问完成，且后续指令不会在屏障前执行），用于需要指令/内存同步（如 TLB 切换、自写代码、DMA 同步）；DMB 只排序数据访问，不等待执行完成。因此 DSB 更严、开销更大，用于设备/同步场景。

acquire/release 映射为 DMB，编译器在原子操作处插入。DSB 更强（等待所有访问完成 + 同步执行），用于指令/设备同步；DMB 只排序数据访问。

• 理解 .aq/.rl 后缀
• 理解只需后缀的场景
• 理解需显式 fence 的场景

RISC-V 原子指令（AMO，如 amoswap.aq、amoadd.rl）可带 acquire（.aq）与 release（.rl）后缀，表示该原子操作具有 acquire/release 语义，无需额外 fence。.aq 保证该 AMO 之后的操作不被重排到它之前，.rl 保证该 AMO 之前的操作不被重排到它之后。只需带后缀 AMO 的场景：acquire/release 语义的原子同步（如无锁队列的发布/获取、原子的 acquire 读、release 写），用 .aq/.rl 即可，无需额外 fence。仍需显式 fence 的场景：需要自身是排它的完整内存屏障（如 seq_cst 全序、需要排序非原子操作、IRIW 等强一致性场景），或需要 fence 提供的全序（如 fence rw,rw），此时需显式 fence 指令（即使在 AMO 前后）。.aq/.rl 只提供单侧 acquire/release，不等同于全屏障。

.aq/.rl 提供 acquire/release 单侧语义，适合原子同步。需全序/排它（seq_cst、排序非原子）时仍需显式 fence。后缀是"带序的原子操作"，fence 是"独立屏障"。

• 理解 volatile
• 理解 atomic
• 理解硬件优化

volatile 只阻止编译器把该变量访问优化掉（每次访问都做，不缓存到寄存器），不提供原子性（不保证读改写原子）也不提供内存顺序约束（不阻止 CPU 重排）。atomic 提供原子性（读改写原子）、内存顺序（acquire/release 等）与可见性同步。volatile 不能替代 atomic 的原因：1) 编译器层面：volatile 阻止单变量优化，但编译器仍可重排 volatile 访问（对非 volatile 变量），且不保证原子；2) 硬件层面：volatile 不阻止 CPU 重排（无屏障），不保证缓存一致性下的顺序可见；3) 原子性：volatile 的复合操作（如 ++）非原子，多线程可能撕裂。编译器可能优化：重排 volatile 与其他操作、把非 volatile 变量缓存。硬件可能优化：乱序执行、缓存延迟。因此并发正确性必须用 atomic（提供原子 + 顺序），volatile 只用于内存映射 IO 等。

volatile 只阻止编译器优化，不提供原子性与顺序。atomic 提供原子 + 内存序。编译器与硬件都有优化，volatile 无法约束，故不能替代 atomic。

• 理解 ABA 问题
• 理解 CAS 循环
• 理解 tagged pointer

Treiber stack 用 CAS 循环：push 读 head 指针（值 A），构造新节点，CAS(head, A, new) 若 head 仍为 A 则成功。ABA 问题：线程读到 head=A，期间另一线程把 A 弹出（head 变 B）再推入 A（head 又变 A），线程的 CAS 看到 head 仍为 A 而成功，但 A 已被复用/释放，导致错误（如 A 指向的节点已被释放）。为何读到"看似相同的旧指针"：CAS 只比较值，A 在"弹出再推入"后值相同，但语义已变（A 节点可能已释放重用）。tagged pointer 解决：在指针中附加一个单调递增的 tag（版本号），每次 push/pop 同时更新 tag（如把 tag 与指针打包，CAS 比较 tag+指针）。若 A 被弹出再推入，tag 已变，CAS 检测到 tag 不同而失败，避免 ABA。tagged pointer 用高位存 tag，低位存指针，从而在 CAS 中一并比较。

ABA 是 CAS 只比较值、未检测"值经历的变化"。tagged pointer 用版本号打包，CAS 比较 tag 检测复用，避免 ABA。这是无锁结构的关键。

• 理解弱内存重排
• 理解差异
• 理解编程意义

x86-TSO 允许的重排范围小：主要允许 store-load 重排（store buffer 导致），store-store、load-load 保持顺序。ARMv8/RISC-V 弱内存允许更大范围：store-store、load-load、load-store、store-load 都可能重排（无屏障时）。差异：弱内存模型允许更多重排，需要更多屏障保证顺序。编程意义：1) 在 x86 上"看起来正确"的代码（依赖 TSO 的顺序保证）移植到 ARM/RISC-V 可能出错，因为弱内存允许更多重排；2) 需使用 C++ 原子与内存序（acquire/release/seq_cst）或显式屏障，而非依赖平台默认顺序；3) 编写可移植并发代码必须显式指定内存序，不能依赖特定平台的重排限制。因此弱内存要求"显式同步"，不应假设平台顺序。

弱内存允许更多重排，x86 TSO 限制少。可移植并发代码必须显式用内存序/屏障，不能依赖 x86 的宽松顺序。差异决定屏障需求。

• 理解 AMO 指令
• 理解 LR/SC
• 理解差异

RISC-V 的 AMO 指令（amoswap、amoadd、amos等）是单条原子读改写指令，硬件实现，支持特定操作（swap、add、and、or、xor、min/max 等），性能高、无失败，适用于这些预定义原子操作（如原子计数 amoadd、atomic swap）。LR/SC（Load-Reserved/Store-Conditional）是通用原子序列：LR 读并标记，SC 条件写，若期间被修改则 SC 失败（需重试）。LR/SC 可构建任意原子操作（如 CAS、复杂读改写），更灵活、通用，但可能有虚假失败、需循环重试、性能略低。适用场景差异：简单原子操作（swap/add 等）用 AMO；需要 CAS 或自定义原子操作（无法用 AMO 表达）用 LR/SC。AMO 是专用高效，LR/SC 是通用灵活。

AMO 用于预定义原子操作（高效无失败），LR/SC 用于 CAS 或自定义原子操作（通用但有虚假失败）。选型按"是否 AMO 覆盖"。

• 理解 RVWMO
• 理解 ARMv8 模型
• 理解差异

RVWMO（RISC-V Weak Memory Ordering）与 ARMv8 都是弱内存模型：都允许大量重排（store-load、store-store、load-load、load-store 在无屏障时可能），都强调"显式屏障/原子指令"而非平台默认顺序。共通：1) 都是弱顺序，需屏障或原子 acquire/release 保证顺序；2) 都支持 acquire/release 语义（RISC-V 的 .aq/.rl 与 ARMv8 的 LDAR/STLR）；3) 都定义多拷贝原子性、累积性等概念。差异：1) 具体触发规则与允许的重排组合细节不同（如某些 load 顺序、multicopy 原子性细节）；2) 屏障指令不同（RISC-V 用 fence pred,succ，ARMv8 用 DMB/DSB）；3) 原子指令形式不同（RISC-V AMO + LR/SC，ARMv8 有 LDADD 等 + 需显式屏障）；4) 形式化规范表述不同（RVWMO 用 acyclic 关系，ARMv8 用 axiomatic 模型，但都强调 acyclic 保证）。编程上两者都需显式内存序。

两者都是弱内存、支持 acquire/release、强调显式同步。差异在具体重排规则、屏障/原子指令形式与形式化表述。编程上均需显式内存序。

• 理解 acquire/release
• 理解临界区保护
• 理解遗漏内存序问题

自旋锁：线程用 acquire 获取锁（CAS/原子比较成功），进入临界区读写共享数据，用 release 释放锁。acquire 获取保证"获取锁后，临界区内的读写不会被重排到获取锁之前"（即获取锁后看到前一个持有者的写入）；release 释放保证"临界区内的读写不会被重排到释放锁之后"（即释放前的写入对下一个获取者可见）。若遗漏内存序：1) 用 relaxed 获取/释放，临界区内的共享读写可能被重排到锁外（在获取锁之前或释放锁之后执行），导致线程在未持锁时访问共享数据，或下一个线程获取锁后看不到完整数据；2) 多核下表现为数据竞争、读到部分/旧数据、临界区保护失效。因此自旋锁必须用 acquire/release（或 seq_cst）保证临界区读写被锁保护。

acquire 获取把临界区读写"夹在"锁内，release 释放保证可见。遗漏内存序使临界区读写逃出锁保护，多核下数据竞争。acquire/release 是自旋锁正确性的关键。

• 理解编译器优化
• 理解 CPU 乱序
• 理解与 atomic 差异

volatile 只阻止编译器把对该变量的访问优化掉（每次访问都做，不缓存寄存器），但不约束 CPU 的乱序执行：CPU 仍可重排 volatile 访问（相对于其他访问），且 volatile 不提供缓存一致性下的顺序保证。在嵌入式多核场景，多个核共享内存，volatile 无法保证：1) 原子性（复合操作可撕裂）；2) 内存顺序（CPU 乱序与缓存失效可能导致跨核可见顺序问题）；3) 跨核可见性（需要屏障/缓存操作）。与 atomic 的根本差异：atomic 提供原子性（读改写原子）+ 内存顺序（acquire/release/seq_cst）+ 跨核可见性同步，由硬件原子指令与屏障实现；volatile 只保证编译期不优化，不涉及原子与顺序。因此多核并发必须用 atomic 或 volatile + 屏障，volatile 单独不足。

volatile 只约束编译器，不约束 CPU。atomic 提供原子 + 顺序 + 可见性。多核场景 volatile 不足，需 atomic（或 volatile 配合屏障）。这是根本差异。

• 理解单地址一致
• 理解多地址顺序
• 理解层次差异

缓存一致性协议（如 MESI）保证单个内存地址的读写一致：所有处理器对同一地址看到一致的写入值（通过缓存行失效/共享机制）。但一致性协议不保证多地址的观察顺序：不同处理器写不同地址，观察者可能看到不同的先后顺序（因为各地址的传播经不同缓存行、不同失效延迟）。屏障指令（fence）约束多地址的观察顺序：通过禁止重排，保证多个地址的读写按所需顺序可见。层次差异：缓存一致性解决"单地址的一致性"（同一地址两次读一致），在缓存层；屏障解决"多地址的顺序"（跨地址的先后可见），在内存序/指令层。两者层次不同：一致性是"单地址值正确"，屏障是"多地址顺序正确"。因此即使一致性协议正常，仍需屏障保证多地址顺序。

一致性解决单地址值一致，屏障解决多地址顺序。层次不同：缓存层 vs 内存序层。多地址顺序不能由单地址一致性保证，需屏障。

• 理解运行期重排
• 理解 memory clobber
• 理解两层防护

编译期重排：编译器在优化时重排内存访问（如把变量读缓存、把读写合并、按数据流重排），发生在编译阶段，由编译器完成。运行期重排：CPU 在乱序执行时重排指令，发生在运行阶段，由硬件完成。两者独立：即使编译器不重排，CPU 可能重排；即使 CPU 不重排，编译器可能重排。正确代码需同时防止两层：1) 编译器层用编译屏障（如 GCC 的 asm volatile 空汇编 + memory clobber，阻止编译器重排内存访问）；2) CPU 层用硬件 fence（如 mfence/dmb），阻止 CPU 重排。memory clobber 只约束编译器，fence 只约束 CPU，两者互补。只防一层则另一层仍可能重排，导致错误。因此正确并发代码需同时约束编译期与运行期。

编译期重排由编译器、运行期重排由 CPU，两独立。memory clobber（编译屏障）只防编译器，fence 只防 CPU，需同时用。只防一层则另一层仍重排。

• 理解 seqlock
• 理解读者 acquire
• 理解与锁比较

seqlock（顺序锁）：写者加锁更新序号并写数据，读者读序号、读数据、再读序号，若两次序号相同（且未变）则数据一致，否则重试。读者为何需要 acquire 语义或显式屏障：读者读序号（读副本）后需保证"读数据"不被重排到"读序号"之后（或读数据与序号读的顺序），acquire 保证读数据看到一致快照；若序号与数据的读取被重排，读者可能读到不一致数据却误判一致。因此读者需 acquire（或屏障）保证读序。与锁保护相比省去了：读者不加锁（无写者时），读者之间无写锁开销，可并行读；写者独占写。对比普通读锁（共享锁），seqlock 读者无锁（在无写者时不阻塞、无锁获取开销），仅写者需锁。读者通过序号检测（无锁读）而非加锁互斥，省去锁获取/释放与读者间互斥。

读者需 acquire 保证读序一致，序号检测替代锁。相对锁保护，读者无锁（无写者时不加锁、可并行），省去锁获取开销与读者互斥。写者独占。

• 理解硬件 fence
• 理解区别
• 理解只需编译器屏障的场景

编译器屏障（GCC 的 asm volatile("" ::: "memory")）只阻止编译器在屏障前后重排内存访问，不产生任何硬件指令、不约束 CPU 乱序。硬件 fence（mfence/dmb 等）是真实指令，约束 CPU 重排。区别：编译器屏障成本极低（无指令），但只在编译期生效；硬件 fence 成本高（有指令），运行期生效。只需编译器屏障的场景：1) 单核（无并发 CPU 乱序）或无需跨核可见性，仅需防止编译器优化/重排（如在单线程内保证访存顺序、防编译器把内存访问缓存）；2) 与硬件原子操作配合时，硬件指令本身已提供顺序（如 x86 的 lock 指令隐含全屏障，无需额外硬件 fence，只需编译器屏障）；3) 内存映射 IO 等只需防止编译器优化。需要硬件 fence 的场景：多核并发、需跨 CPU 可见性顺序（CPU 可能乱序）。

编译器屏障无指令、只防编译器重排；硬件 fence 有指令、防 CPU 重排。单核/无跨核乱序/硬件已提供顺序时只需编译器屏障。多核需硬件 fence。