知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 伪共享与并发性能优化 > 导读:本文从"两个线程各自改自己的变量、逻辑上毫不相干,程序却莫名其妙变慢甚至加核反而更慢"这一具体疑问出发,把 CPU 缓存行与 MESI 缓存一致性、伪共享的产生条件与危害、缓存行填充与 `@Contended`、JDK/中间件里的真实应用、以及如何在业务中定位与规避逐项讲透,最后强调性能问题必须实测。适合已经会写并发代码、开始关心底层性能与缓存行为的同学。 ## 一、先建立全局认知 ### Q:什么是 CPU 缓存行?它为什么会影响并发程序的性能? A:结论先行——CPU 不是以单个字节为单位把内存搬进缓存的,而是以"缓存行(cache line)"为最小单位成块搬运;最常见的缓存行大小是 64 字节,但这个值是常见约定而非绝对,不同 CPU 架构可能是 32、64 或 128 字节,需结合具体硬件确认。 为什么:CPU 访问主内存的延迟远高于访问缓存(L1/L2/L3),所以现代 CPU 都靠多级缓存来减少访问内存的次数。当 CPU 要读某个变量时,它实际上是把包含这个变量的整条缓存行一起加载进自己的缓存。推论是:**多个逻辑上无关的变量,只要落进同一条缓存行,就会被缓存机制强行绑定在一起**。这条性质本身无所谓好坏,但只要这些变量是被不同 CPU 核心并发写入的,问题就来了。 分级结构(示意,具体容量/延迟因架构而异):  *图:伪共享与缓存行填充:以 cache line 为单位的存储层级* ```text ┌──────────────────────────────┐ │ 主内存 │ 容量最大,延迟最高 └──────────────▲───────────────┘ │ 以 cache line 为单位搬运 ┌──────────────┴───────────────┐ │ L3 Cache(共享) │ └──────────────▲───────────────┘ ┌───────┴────────┐ ┌──────┴─────┐ ┌──────┴─────┐ │ L2 / L1(核1)│ │ L2 / L1(核2)│ 各核私有,最小单位是 cache line └────────────┘ └────────────┘ ``` 关键点:缓存行是硬件层面"一起加载、一起失效"的单位。理解这一点,才能理解后面所有围绕"变量摆放位置"的优化手段。适用与不适用:缓存行行为与具体 CPU 强相关;在意识流层面统一说"64 字节"便于讨论,但落到调优必须以目标机器为准。 ### Q:MESI 缓存一致性协议和伪共享有什么关系? A:结论先行——MESI(Modified/Exclusive/Shared/Invalid,即修改/独占/共享/无效)是保证多核缓存内容一致的一套状态机协议;伪共享之所以慢,正是因为它频繁触发 MESI 状态转换,让同一条缓存行在多个核心之间来回"抢所有权"。 为什么:多核各有一份缓存,如果都随便改自己那份,内存就乱了。MESI 给每条缓存行定义了四种状态: | 状态 | 含义 | 谁可以写 | | --- | --- | --- | | M(Modified 修改) | 本核修改过,与内存不一致,本核独有 | 本核可写;写前需先把其他核的副本置为 I | | E(Exclusive 独占) | 未修改,且只有本核缓存了它 | 本核可写(改后变 M) | | S(Shared 共享) | 未修改,可能多个核都缓存了它 | 只能读;写前需先拿到独占权 | | I(Invalid 无效) | 本核这份已失效,需要时重新加载 | 不可读不可写 | 核心规则是:**一个核要写某条缓存行,必须先拿到它的独占权;一旦拿到,其他核里这条缓存行的副本会被标记为无效(I)**。等别的核再想访问,就得重新从内存或从上一持有者那里"要"过来。所以,如果两个核心反复写同一条缓存行里的不同变量,就会不停地互相把对方的副本打无效,缓存行在核心之间来回传递。 证据/示例(两个核心写同一缓存行里不同变量的状态流转):  *图:一条 cache line 在两核间被置 I、变 M 的弹跳过程* ```text 初始:核心1、核心2 都缓存了某条 cache line(S,只读) 核心1 写变量 a(在这条 line 上) → 需要独占权 → 核心2 的副本被置为 I → 核心1 变为 M 核心2 写变量 b(同一条 line 上) → 发现自己副本是 I,要重新拉取 → 让核心1 把 line 交出/回写 → 核心2 得到独占权变 M,核心1 的副本又被置为 I 两个核心反复写 → cache line 在两核之间来回弹跳 → 这就是一致性流量(cache coherence traffic) ``` 关键点:MESI 本身没有问题,它是多核正确工作的基础。问题在于"本该互不相干的变量被放进了同一条缓存行",让 MESI 对它们做了不必要的争抢。不适用场景:如果这些变量是只读的(都在 S 状态),或者只有一个核会写,就不会触发这类转换。真实硬件还有 MOESI、MESIF 等变体,细节有差异,需结合架构确认。 ### Q:伪共享(false sharing)到底是怎么产生的? A:结论先行——当两个(或多个)不同核心并发写入**落在同一条缓存行上的、彼此独立的变量**时,就会发生伪共享;"伪"字的含义是:变量之间逻辑上不共享,硬件上却因为共享同一条缓存行而表现得像在共享。 为什么:伪共享要同时满足三个条件: 1. **有多个核心(或多个线程跑在不同核上)**并发访问; 2. **这些访问中至少包含写操作**(只读不会导致缓存行来回弹跳); 3. **被访问的不同变量落在同一条缓存行里**。 三者缺一,伪共享不成立。特别地,"不同变量落同一行"往往是"顺其自然"发生的:Java 对象在堆里分配,字段紧密排布,一个 `long` 占 8 字节,一条 64 字节的缓存行足以横跨好几个字段;如果对象头占据前 12~16 字节,那么对象里的前几个字段极可能同处一行。 证据/示例(一个刻意制造伪共享的结构): ```java // 两个线程分别高频写 counter0 / counter1 // 它们在同一对象里紧邻,极可能落在同一条 cache line public class SharingCounters implements Runnable { // 注意:这两个 volatile long 字段大概率共享缓存行(受对象头布局影响) private volatile long counter0; private volatile long counter1; public static void main(String[] args) throws InterruptedException { SharingCounters c = new SharingCounters(); Thread t1 = new Thread(c::inc0); Thread t2 = new Thread(c::inc1); t1.start(); t2.start(); t1.join(); t2.join(); } void inc0() { for (long i = 0; i < 100_000_000L; i++) counter0++; } void inc1() { for (long i = 0; i < 100_000_000L; i++) counter1++; } } ``` (上面这段只为演示结构,具体慢多少必须自行压测,本文不给也不建议采信任何具体倍数。) 关键点:伪共享的触发**与你的业务语义无关**,它纯粹由"内存布局 + 并发写"决定。也正因为逻辑无关,很多团队直到做性能压测时才偶然发现,排查起来很隐蔽。不适用场景:单线程、只读共享、或者被访问的变量本就需要同一份数据——这些都不是伪共享问题。 ### Q:为什么 Java 对象里的字段这么容易落到同一条缓存行? A:结论先行——因为 HotSpot 为了省内存,默认把实例字段按大小紧凑排布,加上对象头本身占用十几个字节,一个只有几个字段的小对象往往连一条缓存行都填不满,字段自然共行。 为什么:JVM 默认会对字段做重排与紧凑填充(受字段类型、访问顺序、对齐策略等因素影响),目标是把对象做小、提高内存利用率。对象头通常是 Mark Word(8 字节,64 位下)+ Klass Pointer(视是否开启压缩指针为 4 或 8 字节),再往后排字段。于是像 `class Pair { long a; long b; }` 这样的对象,两个 `long` 加起来才 16 字节,加对象头也远不到 64 字节,`a` 与 `b` 几乎必然落在同一条缓存行上。这不是缺陷,而是"省内存优先"的默认策略——只有在并发写热点时才需要主动干预。 证据/示例(用 JOL 观察字段偏移,示意输出): ```text # 借助 JOL(Java Object Layout)工具可打印对象布局(输出格式随版本变化,仅示意) # OFFSET SIZE TYPE DESCRIPTION # 0 4 (object header) Mark Word # 4 4 (object header) Klass Pointer # 8 8 long Pair.a # 16 8 long Pair.b # Instance size: 24 bytes ← 远小于一条常见的 64 字节缓存行 ``` 关键点:看字段偏移就能判断"谁和谁在同一行"。若两个并发写热点的偏移之差小于缓存行大小,就值得怀疑伪共享。JOL 的 API 与输出随 JDK 版本变化,请以所用版本为准。不适用场景:普通业务对象不需要关心字段布局,这是性能敏感路径才需要做的事。 ## 二、理解核心机制 ### Q:伪共享为什么会让程序变慢? A:结论先行——因为它制造了大量本可避免的缓存一致性流量与缓存未命中:每个核心写一次,就会让另一个核心的缓存副本失效,导致对方下次访问必须重新拉取缓存行,反复如此,CPU 大量时间花在"搬运数据"而非"计算"上。 为什么(定性链条,不给具体数字):  *图:两核交替写造成的未命中循环与四条后果* ```text 核心1 写 a → line 失效(核心2 变 I) 核心2 写 b → 需重新拉 line(缓存未命中)→ 核心1 变 I 核心1 写 a → 需重新拉 line(缓存未命中)→ 核心2 变 I ... 循环往复 ... 后果: 1. L1/L2 缓存命中率大幅下降(每次写都可能未命中) 2. 缓存一致性流量(核间通信/总线事务)显著上升 3. 访存延迟被放大,吞吐随之下降 4. 严重时,加更多线程/核心反而更慢(更多核争同一条 line) ``` 关键点:这里是**定性**描述。真实影响取决于缓存行大小、一致性协议的实现、竞争强度、访问模式、缓存层级与硬件平台,可能是"几乎无感",也可能是"明显变慢",也可能在多核扩展性测试中体现为"吞吐不随核数线性增长"。因此本文不给出任何"提升/降低了多少倍"的数字,凡涉及具体幅度的结论都必须以你自己在目标硬件上的压测为准。 ### Q:真共享和伪共享有什么区别? A:结论先行——真共享(true sharing)是多个核心确实需要访问同一份数据,一致性问题无法回避,只能靠减少争用或改算法;伪共享是多个核心访问的是**不同**数据、只是恰好同处一条缓存行,位置一挪就能消除。 对比表: | 维度 | 真共享 True Sharing | 伪共享 False Sharing | | --- | --- | --- | | 访问对象 | 同一份数据 | 各自不同的数据 | | 是否需要一致性 | 是,本质需要 | 不需要,纯属布局巧合 | | 能否靠"挪位置"消除 | 不能 | 能(填充、拆对象、拆分存储) | | 典型对策 | 减少争用、分段/分片、无锁数据结构 | padding、`@Contended`、独立对象、LongAdder 式分段 | 关键点:区分二者很重要,因为它们的最佳解法完全不同。有人一看到并发写慢就去加 padding,结果问题其实是真共享(比如大家都在抢同一个 `AtomicLong`),加了填充也没用。证据/示例:`LongAdder` 的思路是"先减轻真共享(分段减少同一个变量的争用),再用填充防止分段之间产生伪共享"——两者是叠加使用的。不适用场景:如果根本不存在并发写,这两者都谈不上。 ## 三、解决思路:填充与 @Contended ### Q:缓存行填充(padding)是怎么做的? A:结论先行——填充的思路是"给热点变量周围塞入无用的占位字段,把它'撑'成独占一条缓存行,从而不让它和别人的变量共行"。 为什么:既然麻烦来自"不同变量同处一行",最直接的办法就是把热点变量单独放到一行里。常见做法是:在热点字段前面和后面各放若干个 `long`,加起来占满(或超过)一条缓存行,让热点字段远离相邻变量。既然常见缓存行是 64 字节、`long` 是 8 字节,那么 7 个 `long` 就是 56 字节,配上一个对齐的热点字段,基本能把一条行撑满。 证据/示例(手工填充的经典写法): ```java public final class PaddedCounter { // 前置填充:避免与前一个变量共享缓存行 private long p1, p2, p3, p4, p5, p6, p7; // 热点字段:希望它独占缓存行 private volatile long value; // 后置填充:避免与后一个变量共享缓存行 private long q1, q2, q3, q4, q5, q6, q7; public void inc() { value++; } public long get() { return value; } } ``` 关键点: - 填充会**显著增加内存占用**(一个字段变成十几个字段),只应对真正的热点字段使用,别全局滥用; - 手工填充**不保证 100% 有效**:某些 JVM/编译器可能重排乃至消除"从未被使用"的字段(HotSpot 通常不会消除实例字段,但跨 JVM 实现并无此保证),所以这是"常用但非契约级"的手段; - 填充的宽度要对照目标机器的缓存行大小,写死 7 个 `long` 是按 64 字节假设来的,换架构未必最优。 不适用场景:变量不是并发写热点、或者内存紧张到不能浪费,就不该填充。更稳妥的现代化做法是下面的 `@Contended`。 ### Q:@Contended 注解是怎么回事?-XX:-RestrictContended 有什么用? A:结论先行——`@Contended` 是 JVM 内置的"自动填充"注解,标在字段或类上就能让 JVM 帮你把它隔离到独立缓存行,比手工塞一堆 `long` 更可靠;但它默认只对 JDK 内部类生效,用户类要用就得加启动参数 `-XX:-RestrictContended` 打开。 为什么:手工填充既啰嗦又不可靠,于是 HotSpot 提供了 `@Contended` 注解,由 JVM 在字段布局阶段自动插入填充(padding),并可通过 `-XX:ContendedPaddingWidth` 调整填充宽度(默认值以所用版本为准)。为了避免这个"浪费内存"的能力被滥用,默认开启 `-XX:+RestrictContended`,即只允许 `java.*` 等引导类库使用;普通业务类想用,必须显式关闭该限制。 证据/示例(用户类使用 `@Contended`): ```java import sun.misc.Contended; // JDK 8 中的位置;JDK 9+ 请结合版本确认包名与可访问性 public class PaddedCounter { // 让 JVM 自动把这个字段隔离到独立缓存行 @Contended private volatile long value; public void inc() { value++; } public long get() { return value; } } ``` 启动参数(让用户类的 `@Contended` 生效): ```bash -XX:-RestrictContended ``` 关键点: - `-XX:-RestrictContended` 是**关掉限制**(减号表示关闭该开关),不是打开限制,方向别记反; - 注解所在包名在不同 JDK 版本有变化:JDK 8 常见为 `sun.misc.Contended`,JDK 9 之后迁移到 `jdk.internal.vm.annotation` 等内部包,模块化后直接导入可能受访问限制影响——**具体包名与可用性请以你的 JDK 版本与官方文档为准**; - 也可以把 `@Contended` 标注在整个类上,表示该类实例的字段相互隔离; - 是否真的生效、效果多大,必须在目标 JVM 与硬件上验证,别只看注解就以为万事大吉。 不适用场景:非热点字段、单线程访问、内存敏感的场景都不该加。滥用 `@Contended` 会增加内存占用与 GC 压力,得不偿失。 ### Q:多个线程各自更新数组的不同下标,也会伪共享吗? A:结论先行——会。数组元素连续排布,相邻下标几乎必然共享缓存行;若不同线程分别高频更新相邻下标,就会伪共享,可用"按缓存行对齐的间隔(stride padding)"来缓解。 为什么:数组是内存布局最紧凑的结构,`long[] arr` 里 `arr[0]` 与 `arr[1]` 紧挨着。假设线程 0 一直改 `arr[0]`、线程 1 一直改 `arr[1]`,这两个元素同处一行,就会互相打无效。解决思路很直接——把"不同线程写的槽位"拉开距离,让它们不落在同一行。常见做法是以固定的 stride(步长)访问数组。 证据/示例(每线程独占一个槽位): ```java // 基于"64 字节缓存行、long 为 8 字节"的常见假设:stride = 64 / 8 = 8 // 让每个线程使用相隔 stride 的独立槽位,避免相邻下标共行 public class StripedSlots { private final int stride = 8; private final long[] slots; public StripedSlots(int threads) { this.slots = new long[threads * stride]; } public void add(int threadId, long delta) { slots[threadId * stride] += delta; // 每个线程只更新自己的槽位 } } ``` 关键点:`stride` 依赖缓存行大小与元素类型(`long` 是 8 字节),所以它是**基于常见假设的经验值**,换硬件要重新核对;若元素是 `int`(4 字节),按 64 字节算步长就要取 16。另外,槽位拉开后数组变大、汇总要遍历全部槽位,存在"空间与汇总成本"的取舍。不适用场景:多线程只读、或写入很稀疏时,不必如此设计;此时用普通数组即可。 ## 四、JDK 与中间件中的真实应用 ### Q:LongAdder 的 Cell 为什么要带 @Contended? A:结论先行——因为 `LongAdder` 把热点计数分散到多个 Cell 上以减轻真共享,而这些 Cell 通常会被连续分配、极容易彼此落进同一条缓存行;若不给 Cell 加填充,分散本身又会引入伪共享,前功尽弃。 为什么:`LongAdder`(以及底层 `Striped64`)的核心思想是"分段累加":并发高时,不同线程各自更新一个 Cell,读取时把所有 Cell 汇总。这样把"大家都抢同一个计数器"变成"各改各的槽位"。但问题随之而来——多个 Cell 是相邻分配的数组元素或对象,规模很小,几乎必然共享缓存行。于是 JDK 给 Cell 加了 `@Contended`,让每个 Cell 独占缓存行,避免线程 A 改 Cell[0]、线程 B 改 Cell[1] 时互相把对方的缓存行打无效。 证据/示例(`Striped64`/`LongAdder` 中 Cell 的形态,示意): ```java // 摘自 OpenJDK 的 Striped64 内部类(字段与注解以实际版本为准) // @sun.misc.Contended 静态内部类 Cell static final class Cell { // @Contended 让每个 Cell 独占缓存行,避免相邻 Cell 之间伪共享 volatile long value; Cell(long x) { value = x; } // cas 更新等 } ``` 关键点:这个例子很好地体现了"先分片解决真共享,再填充解决分片带来的伪共享"的叠加设计。类似用法在 JDK 内部还有多处,例如 `Thread` 类中与 `ThreadLocalRandom` 相关的种子/探针字段也被隔离,目的就是避免多个线程的随机数状态互相干扰(字段名与注解形式以实际版本为准)。适用与不适用:`LongAdder` 适合写多读少的统计(如计数),读取的 `sum()` 不是并发下的精确瞬时值;如果需要精确的即时值并且读写都很频繁,得权衡。**具体性能差异请以官方文档与实测为准,本文不给倍数。** ### Q:Disruptor 的 RingBuffer 序号是怎么填的? A:结论先行——Disruptor(高性能内存队列框架)为 RingBuffer 的序号(sequence)使用了缓存行填充,确保生产者、消费者各自追踪的序号不会因为共享缓存行而互相拖慢,这是它追求高吞吐设计里的一环。 为什么:RingBuffer 里生产者和消费者会各自维护、频繁更新序号。如果这些序号变量(或包含它们的对象)紧挨着,生产者写序号会不停让消费者侧的缓存行失效,消费进度与生产进度就会互相干扰。为此 Disruptor 的 `Sequence` 及相关类历史上采用了"前后各补一串 `long`"的经典填充手法(老版本里能看到大量 `p1..p7` 之类的占位字段),后续版本也借助 JVM 的填充机制做隔离。 证据/示例(经典手工填充思路,示意):  *图:Sequence 用前后填充让热点序号独占 cache line* ```text Sequence(示意) ┌──────────────────────────────┐ │ p1 p2 p3 p4 p5 p6 p7 │ ← 前置填充 │ sequenceValue(热点序号) │ │ p8 p9 p10 p11 p12 p13 p14 │ ← 后置填充 └──────────────────────────────┘ 目的:让 sequenceValue 尽量独占一条 cache line ``` 关键点:Disruptor 是"把缓存行利用到极致"的典型工程案例——它同时用填充、序号分片、无锁设计等手段压低争用。这里仅作为设计思路的佐证,**不引用任何具体吞吐数字**,其真实收益依硬件与应用负载而变。 ## 五、定位与规避 ### Q:业务中怎么定位伪共享? A:结论先行——靠"并发扩展性压测 + 硬件性能计数器/采样"两条路交叉验证:先看吞吐是否随并发度/核数不升反降,再用能观察缓存事件的工具定位热点行,最后用 A/B(加/不加填充)确认。 为什么:伪共享没有"报错",只能靠度量。常用手段: | 手段 | 能看什么 | 备注 | | --- | --- | --- | | 并发/核数扩展性压测 | 吞吐随核数/线程数增长是否线性 | 最先做的粗筛,异常时怀疑伪共享 | | JMH 基准 | 受控环境下对比不同布局/填充方案 | Java 基准测试首选,注意避免 JIT 优化误差 | | 硬件性能计数器 | 缓存未命中、一致性相关事件 | Linux 上可用 `perf`,如观察命中已修改行的 HITM 类事件 | | `perf c2c` / VTune 等 | 具体是哪条缓存行、哪两个地址在争 | 定位到"行"级别,最有说服力 | | async-profiler | 以硬件事件(如 `cache-misses`)采样 | 能落到 Java 方法/栈,便于对应到业务代码 | 证据/示例(一段排查路线,示意): ```text 1. 压测:单线程 vs 多线程,观察吞吐/延迟是否随核数不升反降 2. 若怀疑,加/去填充做 A/B 对照,其余条件保持一致 3. 用 perf c2c 或 VTune 看是否存在同一 cache line 上的跨核争用(HITM) 4. 用 async-profiler 以 cache-misses 采样,定位到热点方法/字段 5. 确认后固化:改用独立对象/填充/@Contended,并回归压测 ``` 关键点:**一定要"实测为准"**。伪共享的严重程度与是否真正影响你,取决于硬件与访问模式;不压测就下结论、照搬别人的填充方案,都是不可靠的。 ### Q:规避伪共享有哪些手段?常见误区是什么? A:结论先行——主要手段有隔离热点字段(填充、`@Contended`、拆成独立对象/数组按 stride 隔开)、减少真共享(分片/分段/线程本地累积后汇总)、以及调整数据结构布局;常见误区是"见并发就填充""把真共享误当伪共享""以为填充百利无害"。 手段清单: 1. **隔离热点字段**:对确实是并发写热点的字段用填充或 `@Contended`;把多个热点变量拆到不同对象,让它们天然落在不同缓存行。 2. **按 cache line 对齐的数组布局**:当多个线程各自更新数组的不同下标时,让相邻有效元素之间留出填充(stride 对齐),避免相邻下标共行。 3. **减少真共享**:用 `LongAdder`/分片计数、`ThreadLocal` 累积后汇总等,从根上降低写同一位置的频率。 4. **数据布局与访问模式**:有时把"每个线程一个独立结构"改成"每个线程一个对象实例",比在共享对象上填缝更简单有效。 5. **优先用现成方案**:JDK 已经为它的热点结构做好的隔离(如 `Striped64.Cell`)尽量复用,别自己从零手搓。 常见误区: - **见并发就填充**:只有并发写同一条行的变量才需要,只读或不并发的场景填充纯属浪费内存; - **把真共享当伪共享**:同一个变量被多线程硬抢,加填充无效,得改算法; - **认为手工填充一定生效**:字段可能被布局优化、跨 JVM 无保证,能用 `@Contended` 就用; - **忽视代价**:填充增加内存占用、可能加重 GC 压力,要权衡; - **忽略版本与硬件差异**:缓存行大小、注解位置、参数默认值都随平台/版本变化,**需结合版本确认**,一切结论以目标环境实测为准。 ### Q:加了填充或 @Contended 就一定更快吗? A:结论先行——不一定。填充只在"确实存在多个核心并发写同一条缓存行"时才有正收益,否则它只是白白增加内存占用与 GC 压力,甚至因为布局变化带来别的副作用。 为什么:填充解决的是特定问题。如果你判断错了问题——真实瓶颈其实是不可避免的真共享、锁竞争、GC、或算法复杂度——填充不会起任何作用;而且即便问题判断正确,收益大小也依硬件与负载而变:单核、低并发、访问稀疏的场景本就几乎不触发一致性流量,填充自然看不出差别。 证据/示例(建议的判断与验证顺序): ```text 1. 先用扩展性压测 + 硬件计数器/采样,确认瓶颈是否在"并发写的缓存争用" 2. 再做 A/B 对照:加填充 vs 不加填充,其余条件保持一致 3. 有效 → 保留并回归压测;无效 → 撤掉,别把无用填充留在代码里 ``` 关键点:**一切以实测为准,本文不给出任何具体倍数**。适用与不适用之间没有"默认答案",只有"在你这台机器、这个负载下是不是划算"。不适用场景:内存紧张、字段并非写热点、或问题根本不在缓存维度——这些情况下填充都应慎用。 ## 小结 - CPU 以缓存行为单位搬运数据,最常见是 64 字节,但**这是常见值而非绝对**,因架构而异。 - MESI 保证多核缓存一致;伪共享的慢,来源于同一条缓存行在多个核心间被反复"抢独占、打无效"。 - 伪共享的三个条件:多核并发写 + 含写操作 + 不同变量同处一条缓存行;"伪"是逻辑无关、硬件被迫共享。 - 真共享无法靠挪位置消除,伪共享可以;`LongAdder` 是"先分片治真共享、再填充治伪共享"的叠加范例。 - 解决手段:缓存行填充、`@Contended`(用户类需 `-XX:-RestrictContended`)、拆分独立对象、数组 stride 对齐、以及从根上减少真共享。 - JDK 的 `Striped64.Cell`、`Thread` 的随机数相关字段,以及 Disruptor 的序号,都用了填充/隔离来对抗伪共享。 - 定位靠"扩展性压测 + 硬件计数器/采样 + A/B 对照";**性能影响必须结合硬件与压测实测,不能一概而论,也不存在放之四海皆准的加速比**。 ## 思考题 1. 为什么"只读共享"不会造成伪共享,而"一读一写"就可能? 2. 伪共享和真共享的解法为什么不同?请各举一个 JDK 里的例子。 3. 手工填充为什么"常用但不保证"?`@Contended` 相比它好在哪、代价在哪? 4. `LongAdder` 为什么要先分片、再给 Cell 加填充,两步分别在解决什么问题? 5. 如果你怀疑线上某段代码有伪共享,你会用哪几步去证实或排除?为什么必须做 A/B 对照?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入