Skip to content

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 / 按线程聚合解决)。排查顺序永远是先正确性、再设计、最后性能。

  • 分层要点:

    1. 先分类,别混着讲:DCL 属于“安全发布”问题,错了会看到半初始化对象;单例属于“共享状态与生命周期”问题,错了会串数据、泄漏、多实例;伪共享属于“缓存行与内存带宽”问题,代码逻辑完全正确,只是慢。三者的验证手段也不同:DCL 靠代码审查和 HB 推导,单例靠作用域与状态审计,伪共享靠 perf c2c / JMH 实测。
    2. 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 才成立。
    3. DCL 不是默认答案:整方法 synchronized 正确但每次 get 都加锁;静态内部类 holder 用类初始化锁实现懒加载,不需要 volatile;枚举单例最简、天然防反射和序列化;Spring 容器单例由 IoC 管理。多数业务代码用 holder 或枚举就够,DCL 只在“确实需要延迟初始化 + 已有实例字段 + 不能改结构”时使用。两个 if 都不能省:外层避免每次加锁,内层防止并发进入后重复创建。
    4. 单例的破坏面比实现方式更重要:反射可以 setAccessible(true) 调私有构造;Java 原生序列化 readObject 会新建对象,需要 readResolve;实现 Cloneable 会被 clone 出新实例;多个 ClassLoader(热部署、OSGi、插件)各有各的类,天然多实例;分布式部署下每个 JVM 一个,JVM 单例根本不全局唯一。枚举单例对反射、原生序列化、克隆都安全(JVM 保证),代价是不能继承类、类加载时即初始化。
    5. 有状态单例是最常见的并发事故:单例 + 可变成员变量 = 所有线程共享一块无保护的状态。典型如单例里塞 SimpleDateFormat(非线程安全)、HashMap 缓存、当前用户上下文、可变的计数器。正确姿势:优先无状态;必须共享状态就用 ConcurrentHashMap、原子类、LongAdder、锁或不可变对象;请求级上下文不要放单例字段,用方法参数、ThreadLocal(2.4-8)或 ScopedValue。
    6. Spring singleton 的边界:Spring 的 singleton 是“每个 ApplicationContext / ClassLoader 一个”,不是 JVM 全局;prototype、request、session 作用域另算。Bean 默认单例,所以 Controller/Service 的成员变量会被所有请求线程共享——这是“单例坑”在企业项目里最常见的形态。无状态 Service 没问题,有状态字段必须改成局部变量、线程安全容器或每次新建。
    7. 伪共享的硬件机制:CPU 以缓存行为单位(x86 通常 64 字节,ARM 部分平台 64/128,按平台实测)在核间同步,MESI 协议下某核写一行会把它在别的核置为 Invalid。两个线程分别写同一行的不同变量时,缓存行在核间来回迁移(ping-pong),每次写都可能触发 HITM(Hit Modified)和内存流量,吞吐骤降。它和“真共享”(多线程写同一变量)不同:变量本身不冲突,冲突的是缓存行。
    8. 伪共享的检测与修复:先用 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 在布局阶段处理,但也别滥用——每个填充对象都占内存。
  • 图/流程:

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 前后有屏障,禁止重排 + 建立 HB
text
单例实现选型(从简单到复杂):

  需要延迟加载?
    ├─ 否 ──► 枚举 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 / 字段为 0DCL 缺 volatile,发布重排加 volatile,或改 holder/枚举
日期解析偶发错乱单例里共享 SimpleDateFormatDateTimeFormatter(不可变)或每线程一份
本地缓存丢条目 / size 偏小单例里用普通 HashMap 并发写ConcurrentHashMap / Caffeine
请求之间串用户信息单例字段存请求上下文方法参数 / ThreadLocal / ScopedValue
热部署后监听器重复触发多 ClassLoader 各加载一份单例统一容器管理,清理静态引用
集群计数不一致把 JVM 单例当全局单例分布式计数/锁/选主,或无状态化
反序列化后出现两个实例未实现 readResolve加 readResolve,或改枚举
反射造出第二个实例私有构造可被 setAccessible 绕过枚举 + 构造器防御
计数器吞吐上不去,perf 显示 HITM相邻变量共享缓存行padding / @Contended / 分散对象
加了 padding 没效果JVM 字段重排或变量仍同行用 jol 验证偏移,改 @Contended
内存明显上涨滥用 @Contended/大对象填充只对确认的热点字段使用
  • 深挖点(面试官常追的 6 个):

    1. DCL 为什么必须 volatile:new 的三步(分配、初始化、赋值)中,初始化和赋值可以重排;其他线程在第一层判空时看到非 null,就会跳过锁直接使用半初始化对象。volatile 用 StoreStore/StoreLoad 禁止这个重排,并用写/读 HB 保证初始化结果可见。Java 5 之前旧 JMM 允许 volatile 写与普通写重排,所以那时 DCL 怎么加 volatile 都不对,JSR-133 才修复。
    2. 为什么 holder 不需要 volatile:静态内部类在第一次访问时才初始化,JVM 对类初始化加锁,<clinit> 完成 HB 后续对该类的使用;INSTANCE 在 <clinit> 里一次性赋值,天然安全发布。前提是单例构造不依赖外部可变状态,且没有循环初始化。
    3. 枚举单例为什么最安全:枚举常量在类初始化时创建且只有一个;Java 原生序列化按 name 还原而不是 readObject;Constructor.newInstance 对枚举直接抛 IllegalArgumentException;也不能被 clone。代价是不能继承类、类加载即创建,且无法延迟初始化。
    4. 有状态单例怎么改:先判断状态是否真的需要跨请求共享;能无状态就无状态。必须共享时,用 ConcurrentHashMap、AtomicInteger/LongAdder、显式锁或不可变快照;请求级上下文用参数传递或 ThreadLocal/ScopedValue;不要在单例字段里放 SimpleDateFormat、HashMap、可变 DTO。
    5. 伪共享的硬件细节:缓存一致性以行为单位,MESI 的 Modified 行被别的核读写时要先写回/转移;两个核交替写同一行的不同变量,会导致行在核间迁移,HITM 计数升高、内存带宽被打满。它是性能问题,不影响正确性,所以单测和代码审查发现不了,必须靠 perf c2c 或 JMH。
    6. padding 的边界:对象头、字段对齐、JVM 字段重排都会影响变量落在哪;手工加 7 个 long 在多数 JVM 上有效,但不是规范保证。@Contended 由 JVM 在布局阶段隔离字段/类,可靠但每个实例都变胖;还要注意不同平台缓存行大小不同(x86 64B,部分 ARM 128B),按目标平台实测。伪共享优化必须建立在测量上,不能凭直觉加。
  • 追问链:

    1. DCL 是什么? → 双重检查锁定,外层判空避免每次加锁,内层判空防止并发重复创建。
    2. DCL 为什么需要 volatile? → 防止 new 的初始化与引用赋值重排,避免其他线程看到半初始化对象。
    3. 不加 volatile 会怎样? → 大多数时候正常,高并发/特定 JIT 下偶发 NPE 或字段为 0,极难复现。
    4. Java 5 之前 DCL 为什么无解? → 旧 JMM 允许 volatile 写与普通写重排,volatile 也挡不住发布重排;JSR-133 后才正确。
    5. 两个 if 能省吗? → 外层省了每次加锁但每次都要锁;内层省了会重复创建。都不能省。
    6. DCL 是最佳单例吗? → 不是,holder/枚举更简单安全;DCL 适合已有实例字段、确实要延迟初始化的场景。
    7. 静态内部类 holder 为什么线程安全? → 类初始化由 JVM 加锁,<clinit> 完成 HB 后续使用,实例字段一次性赋值。
    8. holder 需要 volatile 吗? → 不需要,类初始化已经建立 HB。
    9. 枚举单例怎么做? → enum Singleton { INSTANCE; },方法写在枚举里。
    10. 枚举单例为什么防反射? → Constructor.newInstance 对枚举抛 IllegalArgumentException,JVM 不允许反射创建枚举实例。
    11. 枚举单例为什么防序列化? → 原生序列化按枚举名还原,反序列化返回同一常量,不调构造器。
    12. 枚举单例有什么代价? → 不能继承类、类加载时即初始化、无法延迟加载。
    13. 饿汉单例有什么问题? → 类加载即创建,构造重会拖慢启动;如果类因其他静态成员被加载,实例也会提前创建。
    14. 懒汉 synchronized 有什么问题? → 每次 get 都加锁,热点路径吞吐差。
    15. 单例能被反射破坏吗? → 非枚举可以,setAccessible(true) 调私有构造;枚举不行。
    16. 怎么防反射破坏? → 枚举;或在构造器里用标志位,第二次调用抛异常(仍有并发/ClassLoader 边界)。
    17. 单例能被序列化破坏吗? → 能,readObject 会新建实例;需要 readResolve() 返回 INSTANCE。
    18. readResolve 对所有框架都有效吗? → 只对 Java 原生序列化有效;JSON/Hessian 等按字段重建,需要额外处理或枚举。
    19. 克隆会破坏单例吗? → 实现 Cloneable 且不重写 clone 会;重写返回 INSTANCE 或不实现。
    20. 多个 ClassLoader 会怎样? → 每个 loader 各有一份类,静态实例也就各一个;热部署、OSGi、插件场景常见。
    21. 分布式部署下单例唯一吗? → 不唯一,每个 JVM 一个;需要全局唯一要分布式锁/选主/数据库约束。
    22. Spring singleton 是 JVM 单例吗? → 不是,是每个 ApplicationContext/ClassLoader 一个;多容器、多实例部署都不唯一。
    23. Spring 单例 Bean 为什么也有并发坑? → Bean 默认单例,成员变量被所有请求线程共享;有状态字段必须无状态化或加同步。
    24. 单例里能放 SimpleDateFormat 吗? → 不能,它不是线程安全的;用 DateTimeFormatter 或每线程一份。
    25. 单例里能放 HashMap 做缓存吗? → 不能并发写;用 ConcurrentHashMap、Caffeine 等。
    26. 单例适合存用户上下文吗? → 不适合,会串号;用方法参数、ThreadLocal 或 ScopedValue。
    27. 单例有什么设计代价? → 隐藏依赖、难替换、难测试、生命周期不受控;优先依赖注入。
    28. 什么情况下该用单例? → 真正全局唯一、无状态或状态本身线程安全、创建昂贵且可共享的资源(配置、连接池管理、注册表)。
    29. 什么是伪共享? → 多核分别写同一缓存行里的不同变量,导致缓存行来回失效,性能下降。
    30. 伪共享影响正确性吗? → 不影响,变量本身不冲突,只是缓存行冲突。
    31. 伪共享和真共享的区别? → 真共享是写同一变量(需要同步);伪共享是写不同变量但落在同一行(只需布局优化)。
    32. 缓存行多大? → x86 通常 64 字节,ARM 部分平台 64/128,按平台确认。
    33. 怎么检测伪共享? → Linux perf c2c 看 HITM;JMH 对比 padded/unpadded;jol 看字段偏移。
    34. HITM 是什么? → Hit Modified,一个核访问的行在另一个核处于 Modified,需要跨核转移,是伪共享的典型信号。
    35. 怎么修复伪共享? → 字段/对象分离、手工 padding、@Contended、按线程聚合、只读共享。
    36. 为什么加 volatile 不能解决伪共享? → volatile 管可见性和顺序,不管缓存行布局;反而可能增加同步流量。
    37. @Contended 怎么用? → 加在字段或类上;用户类需 --add-exports jdk.internal.vm.annotation=ALL-UNNAMED 和 -XX:-RestrictContended。
    38. 手工 padding 一定有效吗? → 不一定,JVM 可能重排字段或把变量放回同一行;用 jol 验证,或改用 @Contended。
    39. LongAdder 为什么快? → 低竞争时 CAS base,高竞争时分散到 Cell[],Cell 用 @Contended 隔离缓存行,最后 sum() 汇总。
    40. LongAdder 完全解决伪共享吗? → 不,它解决的是竞争热点;如果 Cell 不够或访问模式特殊,仍要测。
    41. 伪共享只在数组里发生吗? → 不是,普通对象的相邻字段、同一对象的两个字段都可能同行。
    42. 读会引发伪共享吗? → 读本身不改行,但会参与行的共享/迁移;主要问题还是写导致 Invalid。
    43. 对象字段顺序是声明顺序吗? → 不保证,JVM 会按对齐/压缩指针重排;不能靠声明顺序推断缓存行。
    44. 怎么排查线上“逻辑对但很慢”的并发代码? → 先看锁竞争/线程状态,再 perf c2c 看 HITM,最后 JMH 验证;不要一上来加 padding。
    45. 面试怎么总结? → 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 一定提升性能,实际要先确认热点,否则只是增加内存。
  • 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)→ 生产案例与取舍 → 排查顺序收尾。