Appearance
2.4-15 经典并发坑:DCL、单例、伪共享
所属:02 Java 运行时 / 2.4 并发 分级:B(按 A 类模板展开) 状态:◐ 初稿 关联:2.2-1、2.2-7、2.4-1、2.4-2、2.4-5、2.4-8
题型:原理 / 场景 / 排查
一句话结论:这三类坑不在一个层面——DCL 是正确性问题(不是锁没加,而是对象发布被重排,必须
volatile);单例是设计问题(首选枚举或静态内部类 holder,有状态单例是并发事故高发区,Spring singleton 也不等于 JVM 单例);伪共享是性能问题(同一缓存行被多核反复改写,不是 JMM 可见性问题,用分离 / padding /@Contended/ 按线程聚合解决)。排查顺序永远是先正确性、再设计、最后性能。分层要点:
- 先分类,别混着讲:DCL 属于“安全发布”问题,错了会看到半初始化对象;单例属于“共享状态与生命周期”问题,错了会串数据、泄漏、多实例;伪共享属于“缓存行与内存带宽”问题,代码逻辑完全正确,只是慢。三者的验证手段也不同:DCL 靠代码审查和 HB 推导,单例靠作用域与状态审计,伪共享靠
perf c2c/ JMH 实测。 - DCL 的本质是发布重排:
instance = new Singleton()在字节码上是new→dup→invokespecial <init>→putstatic,JIT/CPU 允许把putstatic提前到<init>之前,其他线程就会看到“引用非 null、字段仍是默认值”。加volatile后,volatile 写前插 StoreStore、写后插 StoreLoad,禁止初始化与引用赋值的重排,同时写/读建立 HB(2.4-1)。历史很重要:Java 5 之前即使加 volatile,DCL 也不安全,旧 JMM 允许 volatile 写与普通写重排;JSR-133 修正后 DCL 才成立。 - DCL 不是默认答案:整方法
synchronized正确但每次 get 都加锁;静态内部类 holder 用类初始化锁实现懒加载,不需要 volatile;枚举单例最简、天然防反射和序列化;Spring 容器单例由 IoC 管理。多数业务代码用 holder 或枚举就够,DCL 只在“确实需要延迟初始化 + 已有实例字段 + 不能改结构”时使用。两个if都不能省:外层避免每次加锁,内层防止并发进入后重复创建。 - 单例的破坏面比实现方式更重要:反射可以
setAccessible(true)调私有构造;Java 原生序列化readObject会新建对象,需要readResolve;实现Cloneable会被clone出新实例;多个 ClassLoader(热部署、OSGi、插件)各有各的类,天然多实例;分布式部署下每个 JVM 一个,JVM 单例根本不全局唯一。枚举单例对反射、原生序列化、克隆都安全(JVM 保证),代价是不能继承类、类加载时即初始化。 - 有状态单例是最常见的并发事故:单例 + 可变成员变量 = 所有线程共享一块无保护的状态。典型如单例里塞
SimpleDateFormat(非线程安全)、HashMap缓存、当前用户上下文、可变的计数器。正确姿势:优先无状态;必须共享状态就用ConcurrentHashMap、原子类、LongAdder、锁或不可变对象;请求级上下文不要放单例字段,用方法参数、ThreadLocal(2.4-8)或ScopedValue。 - Spring singleton 的边界:Spring 的 singleton 是“每个
ApplicationContext/ ClassLoader 一个”,不是 JVM 全局;prototype、request、session作用域另算。Bean 默认单例,所以 Controller/Service 的成员变量会被所有请求线程共享——这是“单例坑”在企业项目里最常见的形态。无状态 Service 没问题,有状态字段必须改成局部变量、线程安全容器或每次新建。 - 伪共享的硬件机制:CPU 以缓存行为单位(x86 通常 64 字节,ARM 部分平台 64/128,按平台实测)在核间同步,MESI 协议下某核写一行会把它在别的核置为 Invalid。两个线程分别写同一行的不同变量时,缓存行在核间来回迁移(ping-pong),每次写都可能触发 HITM(Hit Modified)和内存流量,吞吐骤降。它和“真共享”(多线程写同一变量)不同:变量本身不冲突,冲突的是缓存行。
- 伪共享的检测与修复:先用
perf c2c record/report(Linux)看 HITM 热点,或用 JMH 对比 padded/unpadded 版本;确认后再优化。手段:把热点字段拆到不同对象或不同缓存行槽位、手工 padding、@Contended(JDK 8 的 JEP 142,用户类需--add-exports jdk.internal.vm.annotation=ALL-UNNAMED+-XX:-RestrictContended)、按线程本地聚合再汇总(LongAdder的Cell就带@Contended)。注意 JVM 可能重排字段,纯手工 padding 不总是可靠;@Contended由 JVM 在布局阶段处理,但也别滥用——每个填充对象都占内存。
- 先分类,别混着讲:DCL 属于“安全发布”问题,错了会看到半初始化对象;单例属于“共享状态与生命周期”问题,错了会串数据、泄漏、多实例;伪共享属于“缓存行与内存带宽”问题,代码逻辑完全正确,只是慢。三者的验证手段也不同:DCL 靠代码审查和 HB 推导,单例靠作用域与状态审计,伪共享靠
图/流程:
text
DCL 的字节码与重排:
private static Singleton instance; // 无 volatile
if (instance == null) { // 第一次检查
synchronized (Singleton.class) {
if (instance == null) { // 第二次检查
instance = new Singleton();
}
}
}
new Singleton() 展开:
new # 分配内存
dup
invokespecial # <init> 初始化
putstatic # 赋值给 instance
允许重排:new → putstatic → invokespecial
→ 其他线程看到 instance != null,但字段还是 0/null
→ 加 volatile:putstatic 前后有屏障,禁止重排 + 建立 HBtext
单例实现选型(从简单到复杂):
需要延迟加载?
├─ 否 ──► 枚举 INSTANCE(最安全) / static final 饿汉
└─ 是
├─ 构造无参、无外部依赖 ──► 静态内部类 holder
├─ 需要带参/可配置 ──► DCL + volatile / 容器管理
└─ 需要防反射+防序列化 ──► 枚举(仍最稳)text
伪共享(两个线程写同一缓存行的不同变量):
Cache Line 0x1000(64B)
┌──────────────┬──────────────┬──────────────┐
│ counterA │ counterB │ padding │
└──────────────┴──────────────┴──────────────┘
▲ 写 ▲ 写
Core 0 Core 1
Core 0 写 → 该行在 Core 0 为 Modified,Core 1 变 Invalid
Core 1 写 → 需要把行从 Core 0 抢过来,Core 0 变 Invalid
→ 缓存行 ping-pong,HITM 升高,吞吐下降text
修复后的布局:
┌──────────────┬──────────────┬──────────────┐
│ counterA + pad│ counterB + pad│ │
└──────────────┴──────────────┴──────────────┘
▲ 写 ▲ 写
Core 0 Core 1
→ 两个变量落在不同缓存行,各自 Modified,互不失效java
// 手工 padding(示意;字段可能被 JVM 重排,生产优先 @Contended 或对象分离)
final class PaddedCounter {
private volatile long value;
private long p1, p2, p3, p4, p5, p6, p7;
}
// @Contended:用户类需额外参数
// --add-exports java.base/jdk.internal.vm.annotation=ALL-UNNAMED
// -XX:-RestrictContended
@jdk.internal.vm.annotation.Contended
final class ContendedCounter {
private volatile long value;
}版本/源码锚点:
- Java 5 / JSR-133:现行 JMM 与 volatile 语义落地,DCL + volatile 从这时起才正确;Java 5 之前 DCL 无解。
- JDK 5+:
enum单例可用;枚举的序列化按name还原、反射Constructor.newInstance对其抛IllegalArgumentException。 - JDK 8 / JEP 142:
@Contended、sun.misc.Contended;JDK 9 起内部类名为jdk.internal.vm.annotation.Contended。 - JDK 8+:
LongAdder/Striped64,Cell带@Contended;ThreadLocalRandom也用类似的分段思路。 - 关键类/方法:
Class#forName与类初始化锁、ObjectInputStream#readObject/readResolve、AccessibleObject#setAccessible、Constructor#newInstance、Singleton的volatile实例字段、Striped64$Cell、@Contended。 - 工具:Linux
perf c2c record/report(看 HITM)、JMH(对比 padding 前后)、jol-core(对象布局与字段偏移)、-XX:-RestrictContended、-XX:ContendedPaddingWidth(JVM 填充宽度,按版本验证默认值)。
单例实现方式对比:
| 实现 | 懒加载 | 线程安全 | 防反射 | 防序列化 | 复杂度 | 适用 |
|---|---|---|---|---|---|---|
饿汉 static final | 否 | 是(类初始化) | 否 | 否 | 低 | 构造轻、启动即用 |
懒汉 synchronized | 是 | 是 | 否 | 否 | 低 | 几乎不推荐,锁粒度粗 |
DCL + volatile | 是 | 是 | 否 | 否 | 中 | 已有实例字段、需延迟初始化 |
| 静态内部类 holder | 是 | 是(类初始化锁) | 否 | 否 | 低 | 无参、无外部依赖,默认首选 |
枚举 INSTANCE | 否(类加载时) | 是 | 是 | 是 | 低 | 最安全,能接受类加载即初始化 |
| 容器/注册式(Spring) | 由容器 | 由容器 | 由容器 | 由容器 | 高 | 需要 IoC、依赖注入、生命周期 |
每线程一份(ThreadLocal) | 是 | 每线程独立 | — | — | 低 | 不是单例,是“线程内单例” |
- 单例破坏方式与防御:
| 破坏方式 | 后果 | 防御 |
|---|---|---|
反射 setAccessible(true) 调私有构造 | 产生第二个实例 | 枚举;或构造器加标志位、第二次调用抛异常 |
| Java 原生序列化反序列化 | readObject 新建实例 | 实现 readResolve() 返回 INSTANCE;或枚举 |
clone() | 复制出新实例 | 不实现 Cloneable;重写 clone() 返回 INSTANCE |
| 多个 ClassLoader / 热部署 | 每个 loader 各一个实例 | 避免重复加载;用容器统一管理;注意静态字段泄漏 |
| 分布式多 JVM | 每个 JVM 一个,不是全局唯一 | 需要全局唯一时用分布式锁 / 选主 / 数据库唯一约束 / 注册中心 |
| 有状态字段被并发访问 | 串数据、丢更新、NPE | 无状态化;并发容器 / 原子类 / 锁;请求上下文移出单例 |
- DCL 与替代方案对比:
| 方案 | 正确性 | 每次 get 开销 | 懒加载 | 备注 |
|---|---|---|---|---|
| 无 volatile 的 DCL | 错误 | 低 | 是 | 半初始化风险,Java 5 前也没有正确写法 |
整方法 synchronized | 正确 | 有锁开销 | 是 | 简单但热点路径不划算 |
DCL + volatile | 正确 | 一次 volatile 读 | 是 | 两次判空都不能省 |
| 静态内部类 holder | 正确 | 类初始化后接近零 | 是 | 依赖类初始化 HB,最常见推荐 |
| 枚举 | 正确 | 接近零 | 否 | 防反射/序列化最好 |
- 伪共享检测与修复:
| 手段 | 类型 | 说明 |
|---|---|---|
perf c2c record/report | 检测 | Linux 上看 HITM 热点缓存行与调用栈 |
| JMH padded vs unpadded | 检测 | 微基准对比,排除噪声后看吞吐/延迟 |
jol-core | 诊断 | 打印字段偏移,确认变量是否同处一行 |
| 对象/字段分离 | 修复 | 把热点变量拆到不同对象或不同数组槽位 |
| 手工 padding | 修复 | 填充 long 占位;注意 JVM 可能重排字段 |
@Contended | 修复 | JVM 布局时隔离;用户类需 flags,避免滥用 |
按线程聚合(LongAdder) | 修复 | 先本地累加再汇总,减少同一地址竞争 |
| 只读共享 / 不可变 | 规避 | 不写就不会让行失效 |
- 常见并发坑清单:
| 现象 | 根因 | 处理 |
|---|---|---|
| 单例偶发 NPE / 字段为 0 | DCL 缺 volatile,发布重排 | 加 volatile,或改 holder/枚举 |
| 日期解析偶发错乱 | 单例里共享 SimpleDateFormat | DateTimeFormatter(不可变)或每线程一份 |
| 本地缓存丢条目 / size 偏小 | 单例里用普通 HashMap 并发写 | ConcurrentHashMap / Caffeine |
| 请求之间串用户信息 | 单例字段存请求上下文 | 方法参数 / ThreadLocal / ScopedValue |
| 热部署后监听器重复触发 | 多 ClassLoader 各加载一份单例 | 统一容器管理,清理静态引用 |
| 集群计数不一致 | 把 JVM 单例当全局单例 | 分布式计数/锁/选主,或无状态化 |
| 反序列化后出现两个实例 | 未实现 readResolve | 加 readResolve,或改枚举 |
| 反射造出第二个实例 | 私有构造可被 setAccessible 绕过 | 枚举 + 构造器防御 |
| 计数器吞吐上不去,perf 显示 HITM | 相邻变量共享缓存行 | padding / @Contended / 分散对象 |
| 加了 padding 没效果 | JVM 字段重排或变量仍同行 | 用 jol 验证偏移,改 @Contended |
| 内存明显上涨 | 滥用 @Contended/大对象填充 | 只对确认的热点字段使用 |
深挖点(面试官常追的 6 个):
- DCL 为什么必须 volatile:
new的三步(分配、初始化、赋值)中,初始化和赋值可以重排;其他线程在第一层判空时看到非 null,就会跳过锁直接使用半初始化对象。volatile 用 StoreStore/StoreLoad 禁止这个重排,并用写/读 HB 保证初始化结果可见。Java 5 之前旧 JMM 允许 volatile 写与普通写重排,所以那时 DCL 怎么加 volatile 都不对,JSR-133 才修复。 - 为什么 holder 不需要 volatile:静态内部类在第一次访问时才初始化,JVM 对类初始化加锁,
<clinit>完成 HB 后续对该类的使用;INSTANCE在<clinit>里一次性赋值,天然安全发布。前提是单例构造不依赖外部可变状态,且没有循环初始化。 - 枚举单例为什么最安全:枚举常量在类初始化时创建且只有一个;Java 原生序列化按
name还原而不是readObject;Constructor.newInstance对枚举直接抛IllegalArgumentException;也不能被clone。代价是不能继承类、类加载即创建,且无法延迟初始化。 - 有状态单例怎么改:先判断状态是否真的需要跨请求共享;能无状态就无状态。必须共享时,用
ConcurrentHashMap、AtomicInteger/LongAdder、显式锁或不可变快照;请求级上下文用参数传递或ThreadLocal/ScopedValue;不要在单例字段里放SimpleDateFormat、HashMap、可变 DTO。 - 伪共享的硬件细节:缓存一致性以行为单位,MESI 的 Modified 行被别的核读写时要先写回/转移;两个核交替写同一行的不同变量,会导致行在核间迁移,HITM 计数升高、内存带宽被打满。它是性能问题,不影响正确性,所以单测和代码审查发现不了,必须靠
perf c2c或 JMH。 - padding 的边界:对象头、字段对齐、JVM 字段重排都会影响变量落在哪;手工加 7 个
long在多数 JVM 上有效,但不是规范保证。@Contended由 JVM 在布局阶段隔离字段/类,可靠但每个实例都变胖;还要注意不同平台缓存行大小不同(x86 64B,部分 ARM 128B),按目标平台实测。伪共享优化必须建立在测量上,不能凭直觉加。
- DCL 为什么必须 volatile:
追问链:
- DCL 是什么? → 双重检查锁定,外层判空避免每次加锁,内层判空防止并发重复创建。
- DCL 为什么需要 volatile? → 防止
new的初始化与引用赋值重排,避免其他线程看到半初始化对象。 - 不加 volatile 会怎样? → 大多数时候正常,高并发/特定 JIT 下偶发 NPE 或字段为 0,极难复现。
- Java 5 之前 DCL 为什么无解? → 旧 JMM 允许 volatile 写与普通写重排,volatile 也挡不住发布重排;JSR-133 后才正确。
- 两个 if 能省吗? → 外层省了每次加锁但每次都要锁;内层省了会重复创建。都不能省。
- DCL 是最佳单例吗? → 不是,holder/枚举更简单安全;DCL 适合已有实例字段、确实要延迟初始化的场景。
- 静态内部类 holder 为什么线程安全? → 类初始化由 JVM 加锁,
<clinit>完成 HB 后续使用,实例字段一次性赋值。 - holder 需要 volatile 吗? → 不需要,类初始化已经建立 HB。
- 枚举单例怎么做? →
enum Singleton { INSTANCE; },方法写在枚举里。 - 枚举单例为什么防反射? →
Constructor.newInstance对枚举抛IllegalArgumentException,JVM 不允许反射创建枚举实例。 - 枚举单例为什么防序列化? → 原生序列化按枚举名还原,反序列化返回同一常量,不调构造器。
- 枚举单例有什么代价? → 不能继承类、类加载时即初始化、无法延迟加载。
- 饿汉单例有什么问题? → 类加载即创建,构造重会拖慢启动;如果类因其他静态成员被加载,实例也会提前创建。
- 懒汉
synchronized有什么问题? → 每次 get 都加锁,热点路径吞吐差。 - 单例能被反射破坏吗? → 非枚举可以,
setAccessible(true)调私有构造;枚举不行。 - 怎么防反射破坏? → 枚举;或在构造器里用标志位,第二次调用抛异常(仍有并发/ClassLoader 边界)。
- 单例能被序列化破坏吗? → 能,
readObject会新建实例;需要readResolve()返回INSTANCE。 readResolve对所有框架都有效吗? → 只对 Java 原生序列化有效;JSON/Hessian 等按字段重建,需要额外处理或枚举。- 克隆会破坏单例吗? → 实现
Cloneable且不重写clone会;重写返回INSTANCE或不实现。 - 多个 ClassLoader 会怎样? → 每个 loader 各有一份类,静态实例也就各一个;热部署、OSGi、插件场景常见。
- 分布式部署下单例唯一吗? → 不唯一,每个 JVM 一个;需要全局唯一要分布式锁/选主/数据库约束。
- Spring singleton 是 JVM 单例吗? → 不是,是每个
ApplicationContext/ClassLoader 一个;多容器、多实例部署都不唯一。 - Spring 单例 Bean 为什么也有并发坑? → Bean 默认单例,成员变量被所有请求线程共享;有状态字段必须无状态化或加同步。
- 单例里能放
SimpleDateFormat吗? → 不能,它不是线程安全的;用DateTimeFormatter或每线程一份。 - 单例里能放
HashMap做缓存吗? → 不能并发写;用ConcurrentHashMap、Caffeine 等。 - 单例适合存用户上下文吗? → 不适合,会串号;用方法参数、
ThreadLocal或ScopedValue。 - 单例有什么设计代价? → 隐藏依赖、难替换、难测试、生命周期不受控;优先依赖注入。
- 什么情况下该用单例? → 真正全局唯一、无状态或状态本身线程安全、创建昂贵且可共享的资源(配置、连接池管理、注册表)。
- 什么是伪共享? → 多核分别写同一缓存行里的不同变量,导致缓存行来回失效,性能下降。
- 伪共享影响正确性吗? → 不影响,变量本身不冲突,只是缓存行冲突。
- 伪共享和真共享的区别? → 真共享是写同一变量(需要同步);伪共享是写不同变量但落在同一行(只需布局优化)。
- 缓存行多大? → x86 通常 64 字节,ARM 部分平台 64/128,按平台确认。
- 怎么检测伪共享? → Linux
perf c2c看 HITM;JMH 对比 padded/unpadded;jol看字段偏移。 - HITM 是什么? → Hit Modified,一个核访问的行在另一个核处于 Modified,需要跨核转移,是伪共享的典型信号。
- 怎么修复伪共享? → 字段/对象分离、手工 padding、
@Contended、按线程聚合、只读共享。 - 为什么加 volatile 不能解决伪共享? → volatile 管可见性和顺序,不管缓存行布局;反而可能增加同步流量。
@Contended怎么用? → 加在字段或类上;用户类需--add-exports jdk.internal.vm.annotation=ALL-UNNAMED和-XX:-RestrictContended。- 手工 padding 一定有效吗? → 不一定,JVM 可能重排字段或把变量放回同一行;用
jol验证,或改用@Contended。 LongAdder为什么快? → 低竞争时 CASbase,高竞争时分散到Cell[],Cell 用@Contended隔离缓存行,最后sum()汇总。LongAdder完全解决伪共享吗? → 不,它解决的是竞争热点;如果Cell不够或访问模式特殊,仍要测。- 伪共享只在数组里发生吗? → 不是,普通对象的相邻字段、同一对象的两个字段都可能同行。
- 读会引发伪共享吗? → 读本身不改行,但会参与行的共享/迁移;主要问题还是写导致 Invalid。
- 对象字段顺序是声明顺序吗? → 不保证,JVM 会按对齐/压缩指针重排;不能靠声明顺序推断缓存行。
- 怎么排查线上“逻辑对但很慢”的并发代码? → 先看锁竞争/线程状态,再
perf c2c看 HITM,最后 JMH 验证;不要一上来加 padding。 - 面试怎么总结? → DCL 是发布正确性(volatile + JSR-133)→ 单例优先 holder/枚举、警惕有状态与多实例 → 伪共享是缓存行性能问题,先测量再 padding。
生产案例/取舍(示例,替换成你的项目):
- DCL 单例没加 volatile,大促压测偶发 NPE / 字段为 0;加 volatile 后消失。根因是发布重排,不是锁没加。
- 单例 Service 里放了
SimpleDateFormat成员变量,日期解析偶发错乱/抛异常;换DateTimeFormatter后解决。 - 单例里用
HashMap做本地缓存,并发写导致条目丢失、size 偏小;换ConcurrentHashMap/Caffeine。 - 单例里存“当前登录用户”,异步线程读到别人的用户;改为方法参数传递 +
ThreadLocal/ScopedValue,并在请求结束清理。 - Spring 单例 Bean 有可变成员变量,压测时请求间串数据;改成局部变量或线程安全容器。
- 热部署后定时任务/监听器重复执行,旧 ClassLoader 的静态实例没释放;统一由容器管理并清理引用。
- 集群里用 JVM 单例做全局限流计数器,各节点计数不一致;改成 Redis 计数/分布式限流。
- 单例实现了
Serializable但没写readResolve,缓存反序列化后出现两个实例;补readResolve后解决。 - 有人用反射调私有构造做测试,线上被利用造出第二个实例;改枚举单例。
- 高频计数器两个字段相邻,
perf c2c显示 HITM 高;字段分离 + padding 后吞吐明显提升。 - 两个线程分别更新
long[]的相邻槽位,压测上不去;改成每线程独立数组再汇总。 - 给所有字段都加
@Contended,内存涨了一大截但性能没变;只对确认的热点字段使用,优化前先测量。 - 取舍:DCL 换延迟初始化,代价是复杂度和 volatile 读;holder 换简单安全,代价是不能带参;枚举换最强防御,代价是不能继承/不能懒加载;容器单例换依赖注入,代价是生命周期绑定容器;padding 换吞吐,代价是内存与可读性;
@Contended换可靠隔离,代价是 flags 和内存。
易错点:
- 认为 DCL 只要加
synchronized就够了,实际实例字段还必须volatile。 - 认为 Java 5 之前加 volatile 的 DCL 也安全,实际旧 JMM 下无解。
- 认为 DCL 是最佳单例写法,实际 holder/枚举通常更简单安全。
- 认为 holder 也需要 volatile,实际类初始化已建立 HB。
- 认为私有构造器能防反射,实际
setAccessible(true)可以绕过(枚举除外)。 - 认为单例天然线程安全,实际只保证“一个实例”,不保证实例状态线程安全。
- 认为 Spring singleton 就是 JVM 全局单例,实际是每个容器/ClassLoader 一个。
- 认为多实例部署下单例仍全局唯一,实际每个 JVM 各一个。
- 认为单例适合存请求上下文,实际会串号,必须移出单例。
- 认为
readResolve对所有序列化框架有效,实际只对 Java 原生序列化有效。 - 认为克隆不会破坏单例,实际实现
Cloneable且不重写就会。 - 认为枚举单例可以被反射创建,实际 JVM 会抛
IllegalArgumentException。 - 认为枚举单例没有缺点,实际不能继承类、类加载即初始化。
- 认为伪共享是 JMM/可见性问题,实际是缓存行性能问题,不影响正确性。
- 认为加 volatile 能解决伪共享,实际 volatile 不管缓存行布局。
- 认为伪共享只发生在数组,实际普通对象的相邻字段也会。
- 认为缓存行都是 64 字节,实际不同平台可能是 64/128。
- 认为对象字段按声明顺序排列,实际 JVM 可能重排。
- 认为手工 padding 一定有效,实际 JVM 重排可能让填充失效。
- 认为
@Contended用户类可以直接用,实际要--add-exports+-XX:-RestrictContended。 - 认为
LongAdder是专门解决伪共享的,实际它先解决竞争,Cell的@Contended才顺带缓解伪共享。 - 认为 perf 显示某函数耗时高就是伪共享,实际要看 HITM 和缓存行热点。
- 认为伪共享只影响写,实际读参与共享/迁移,写才是主要失效来源。
- 认为单例能提升性能,实际只有共享昂贵资源时才划算,否则增加耦合。
- 认为单例没有测试成本,实际隐藏依赖、难 mock、生命周期难控。
- 认为 DCL 的内层
if可以省,实际并发进入会重复创建。 - 认为 DCL 的外层
if可以省,实际退化成每次加锁。 - 认为单例越早初始化越好,实际可能拖慢启动、放大启动依赖失败。
- 认为加 padding 一定提升性能,实际要先确认热点,否则只是增加内存。
- 认为 DCL 只要加
30 秒口述稿:
这三类坑分三个层面。DCL 是正确性问题:
new的初始化和引用赋值可能重排,别的线程会看到非 null 但字段为 0 的对象,所以实例字段必须 volatile;Java 5 之前的旧 JMM 连 volatile 都救不了,JSR-133 之后才对。单例是设计问题:优先静态内部类 holder 或枚举,holder 靠类初始化 HB,枚举连反射和序列化都防住;真正的事故多来自有状态单例,Spring 单例 Bean 的成员变量就是典型,还有多 ClassLoader 和多 JVM 下“单例不唯一”。伪共享是性能问题:多核写同一缓存行的不同变量,行来回失效,perf c2c看 HITM,用对象分离、padding、@Contended或LongAdder解决;它不影响正确性,必须实测后再优化。
- 3 分钟展开顺序:结论(正确性 / 设计 / 性能三层)→ DCL 的字节码重排与 volatile → JSR-133 历史与两个 if → 单例实现对比与选型 → 反射/序列化/克隆/ClassLoader/分布式五类破坏 → 有状态单例与 Spring singleton → 伪共享的缓存行与 MESI → 检测(perf c2c/JMH/jol)→ 修复(分离/padding/@Contended/LongAdder)→ 生产案例与取舍 → 排查顺序收尾。