JMM、volatile 与 synchronized:共享可变状态的可见性合同与选型边界

JMM、volatile 与 synchronized:共享可变状态的可见性合同与选型边界

Hello,我是小兔大白糖。 配置中心刚把开关推下去,一半实例已经按新规则拒单,另一半还在旧阈值上放行——排障到最后,经常不是「多核不够快」,而是跨线程共享可变状态没有写清同步边。写成这篇,给熟悉线程池、连接池、超时重试,却还把 volatile 当「万能线程安全」的后端同学:做一次业界向的 JMM / volatile / synchronized 选型调研。

JMM规定共享可变状态的可见与有序;volatile 不是万能线程安全,复合操作仍要锁或原子类。

说明:伪流程与场景均为教学脱敏 / 示意,不绑定某司业务栈。读完带走的是心智模型与取舍清单,不是备考提纲。

估计阅读时间:10 分钟


目录


为什么现在要关心这件事?

JMM(Java Memory Model,Java 内存模型)管的不是「多核一定更快」,而是共享可变状态何时对别的线程可见、何种重排被禁止——一份可预测的并发合同。

现场里常见的误伤:

你看到的现象常见真相
开关已改,部分 worker 仍走旧分支写端未建立可见性边;读者一直拿着工作内存里的旧副本
volatile int 计数「偶尔少」复合操作 i++ 不是原子;看得见最新值仍可能丢更新
双重检查「看起来线程安全」引用发布与对象字段初始化之间缺安全发布;历史坑与现代写法都绕不过 volatile / 最终字段等合同
持锁做远程调用,吞吐塌了互斥买到了正确性,账单是临界区过长
「加了锁就绝对安全」锁只保护进了同一把锁的临界区;漏字段、换锁对象、无锁读,合同立刻破

和上一篇线程池「容量合同」同一类问题:你以为在调性能旋钮,其实在谈失败形态是否可预期。本文钉三件事——JMM 合同边界、volatile 能保什么保不了什么、何时上 synchronized / 显式锁 / 原子类。


心智模型是什么:白板与便签

主比喻:会议室白板(主内存)+ 每人手里的便签(工作内存)。

线程一般不直接在白板上涂改,而是抄到便签上算,再择机贴回白板。两人各抄一份、各改各的、再贴回去——丢更新毫不奇怪。

JMM 心智模型:主内存白板与线程工作内存便签,经 read/load 与 store/write 交互
JMM 心智模型:主内存白板与线程工作内存便签,经 read/load 与 store/write 交互 · 点击查看 SVG 原图
比喻角色JMM / 工具对应人话
白板主内存中的共享变量所有线程理论上的「权威副本」所在处
便签工作内存 / CPU 缓存等实现层线程私有可见的工作副本;何时与白板对齐不保证「立刻」
「写完立刻擦白板并通知重抄」volatile 写后的可见与特定重排约束适合广播开关、安全发布一类「单写多读」叙事
「进会议室关门;出门时便签与白板对齐」synchronized / 显式锁的进入与退出互斥 + 可见;临界区长短直接决定吞吐账单

类比局限一句说清:白板解释「抄写、回写、对齐」;解释不了硬件缓存一致性协议细节,也解释不了业务上「这个开关漏切一次能不能赔得起」——那是 SLA,不是 JMM 条款。 现代 JVM 也不再要求你背早期教材里的八种内存交互原语;日常够用的是可见性、有序性、原子性三块语义,以及 happens-before。


JMM 精确定义是什么?

先问清「要互斥还是只要可见」,再选工具;别先贴 volatile 或锁当护身符。

三块语义(分享向够用)

语义合同含义典型工具
可见性一线程的写,在约定边之后,对另一线程的读可见volatile 读写;锁的 unlock → 后续 lock;线程 start / join 等
有序性禁止跨越同步点的特定指令重排,使程序在合同边内「看起来有序」同上;另有 final 安全发布等规则
原子性一段读改写作为整体不被打断synchronized / 显式锁;Atomic* / LongAdder 等

硬边界:

  1. 跨线程共享可变状态,必须有明确同步边——「碰巧还没复现」不是合同。
  2. volatile = 可见 + 禁止特定重排,不是复合动作的原子性——i++、check-then-act 仍要原子类或锁。
  3. synchronized / 显式锁解决互斥 + 退出时的可见刷新——选型看临界区长短、要不要条件等待、要不要可中断 / 限时获取。

和「性能优化」的关系

JMM 保证的是可预测行为,不是自动加速。多核只是把「看不见最新值」「重排露出中间态」的概率抬高;合同写清楚,压测与排障才谈得上。


volatile、锁、原子类怎么选?

业界常见三条路:广播可见、互斥临界区、无锁细粒度更新——每条都有代价。

选型分流:只要可见用 volatile 或安全发布;还要互斥用锁或原子类;勿用 volatile 扛复合更新
选型分流:只要可见用 volatile 或安全发布;还要互斥用锁或原子类;勿用 volatile 扛复合更新 · 点击查看 SVG 原图
模式适用你多买到什么主要代价
A. volatile 标志 / 配置句柄简单开关、状态机枚举、发布已构造完的不可变快照引用读者无锁即可看见最新引用或标志不能保复合动作;关联多字段中间态仍可能被读到
B. synchronized / 内置监视器短临界区互斥、需要 wait / notify 条件协作原子 + 可见 + 有序边;语法直接竞争激烈时吞吐下降;持锁做 IO 会放大排队
C. 显式锁(如 ReentrantLock)要可中断、限时、公平策略、多条件队列比内置锁更可组合的获取 / 释放语义API 更啰嗦;忘记 unlock 是经典事故
D. java.util.concurrent.atomic / 累加器单变量 CAS 更新、统计计数细粒度、常无整段互斥高竞争下 CAS 空转;复杂不变量仍要锁或重构数据

分享向默认推荐:

  • 只要「告诉大家改了」 → volatile 或不可变对象的安全发布。
  • 有读改写或不变量跨字段 → 原子类或锁;别用 volatile 硬扛。
  • 临界区可能阻塞 / 要公平 / 要多条件 → 显式锁比盲目加长 synchronized 块更可控——但要付释放纪律与复杂度账单。

代价必须写进选型:互斥买正确性,卖的是并行度;volatile 买便宜可见,卖的是「复合操作仍不安全」的错觉。


happens-before 为什么是选型地板?

happens-before(先行发生)不是墙上时钟的先后,而是「若 A happens-before B,则 A 的结果对 B 可见」的可见性保证。

日常选型高频用到的几条(公开教材与 JLS 叙述的交集,不必背编号):

规则(人话)选型含义
同线程内程序次序单线程里前面的写,后面的读能看见——跨线程不自动成立
监视器:unlock happens-before 后续同一把锁的 lock出临界区前的写入,进同一把锁的线程能看见
volatile 写 happens-before 后续对该变量的读开关 / 发布引用常用这条边
线程 start / join启动前写入对线程内可见;join 返回后能看见该线程的写入
传递性可把「写字段 → volatile 写引用 → 读者 volatile 读 → 读字段」串成安全发布链

实现层常听到 内存屏障(memory barrier / fence):JVM 与硬件用屏障落实上述合同。分享向不必背 StoreStore / LoadLoad 表;要带走的是——没有 happens-before 边,就没有跨线程可见承诺。

关于锁实现演进(业界注记,非备考重点):历史上 HotSpot 上 synchronized 有偏向 / 轻量 / 重量等优化路径;JDK 15(JEP 374)起默认禁用偏向锁,因为线程池与异步框架下「单线程反复持同一锁」假设常不成立,撤销成本可能高于收益。日常选型仍按临界区长度与竞争程度说话,而不是背 Mark Word 位图。


热开关、计数、安全发布怎么选?

三个最小场景,对应三种合同;代码刻意少,结论应能离开代码独立成立。

1)配置热开关——只要可见

教学伪流程:

writer:  configFlag = true          # volatile 写
readers: if (configFlag) ...        # volatile 读 → 看见最新开关

适合:风控快拒开关、功能门控、只读配置句柄替换。
不适合:if (!inited) { init(); inited = true; } 这种 check-then-act——多个读者仍可能同时 init。

2)本地计数 / 限额——要原子更新

volatile int c; c++ 不够:读、加、写三步可交错。
业界常见替代:AtomicInteger / LongAdder(统计场景)、或短临界区锁保护「读改写 + 不变量」。

3)安全发布——引用与内容一起可见

教学意图:线程 A 构造不可变(或事实不可变)对象,把引用交给线程 B。

publisher:
  obj = new Payload(...);   # 写完字段
  ref = obj;                # volatile 写引用(或 static 初始化 / final 发布等安全模式)

subscriber:
  p = ref;                  # volatile 读
  use(p.fields);            # 应看见构造完成的内容

双重检查锁定(DCL)若发布的是可变构造中的对象,引用字段通常需要 volatile,否则读者可能看见「引用非空但字段未初始化完」的中间态——这是公开讨论多年的发布安全问题,不是某厂内部传说。

更省事的替代:不可变对象 + 静态初始化、或 final 字段的安全初始化规则;能不用 DCL 就不用。


常见坑有哪些?

  1. 用 volatile 代替锁做 check-then-act
    看得见最新标志,拦不住两个人同时通过「尚未初始化」的窗口。

  2. 超大临界区持锁做 IO / 远程调用
    正确性账单用吞吐与尾延迟来付;业界更常把「算完再发布不可变快照」或「锁外 IO + 有界重试」拆开。

  3. 双重检查不写清发布安全
    只同步 new 却让引用字段普通可见——读者可能读到半成品。现代写法要显式 volatile 或换安全发布模式。

  4. 一把大锁保护整条业务链路
    和「全省务一个线程池」同构:省事,故障日账单一次性收齐。按不变量拆锁,或改成原子状态机 + 不可变快照。

  5. 无锁读、有锁写却假设「读也能看见」
    若读路径根本不经过同一把锁或 volatile,JMM 不保证你看见写路径的更新。

  6. 把「我本机没复现」当成线程安全证明
    可见性 bug 依赖时序与硬件;压测与代码审查要比「碰巧绿」更值钱。


该怎么选?一句话结论

  1. 共享可变 → 先问「只要可见,还是还要互斥 / 复合更新」;没有同步边就不要默认「多线程自然一致」。
  2. volatile 适合广播与安全发布引用;i++、check-then-act、多字段不变量走原子类或锁。
  3. 短临界区用 synchronized 往往够用;要可中断、限时、公平、多条件时再上显式锁——并付释放纪律。
  4. 能发布不可变快照就少共享可变;减少跨线程可变面积,比堆更多锁更稳。
  5. 用 happens-before 复述你的设计:「谁写、谁读、中间哪条边」说不清,就还没设计完。

下一步:把现有共享字段列一张表——每个字段标注「发布方式 / 读路径是否经过同一同步边 / 是否存在复合更新」→ 能降成不可变或 volatile 句柄的先降 → 剩余互斥用短临界区或原子类收口。

系列导航:

  • 上一篇:/blog/java_threadpool_params_and_isolation/(java-core-deep seriesOrder 1)— 线程池七参数与快慢路径隔离
  • 本篇(seriesOrder 2):JMM、volatile 与 synchronized 的可见性合同与选型边界