Java内存模型(Java Memory Model,简称JMM)是Java并发编程的基石。它定义了Java虚拟机(JVM)如何管理内存访问,确保多线程环境下数据的一致性与可见性。不同于物理内存结构,JMM是一种抽象模型,用于屏蔽底层硬件差异,使开发者能基于统一语义编写可移植的并发程序。
本图解以可视化方式拆解JMM的关键组件:主内存(Main Memory)与工作内存(Working Memory)之间的交互关系,以及线程如何通过读/写、锁定/解锁等操作实现内存同步。理解JMM不是为了死记规则,而是为了解决实际开发中出现的可见性、有序性、原子性三大问题——例如为何两个线程对同一变量的修改互相不可见?为何看似简单的i++操作在并发下会出错?
不同于“内存模型”字面含义所暗示的物理结构,JMM本质是一组规范,约束着JVM实现者如何组织线程与内存交互,同时赋予开发者可预期的行为语义。它不规定具体实现方式(如x86的缓存一致性协议),但要求所有符合规范的JVM实现必须保证:
本文将结合图解、代码示例与常见场景,层层深入剖析JMM原理,助您真正掌握并发编程的底层逻辑。
下图展示线程与内存之间的标准交互路径:
「线程A」←→「工作内存A」 ↑ ↑ 「主内存」←→「工作内存B」←→「线程B」
所有共享变量(即实例字段、静态字段和数组元素)都存储于主内存中;每个线程拥有独立的工作内存,用于保存该线程使用到的变量副本(从主内存拷贝而来)。线程对变量的所有操作(读、写)必须在工作内存中进行,不能直接读写主内存数据。不同线程之间无法访问对方的工作内存,变量值传递需经主内存中转。
JMM定义了八种原子操作(lock/unlock为底层同步原语,read/load/use/assign/store/write为变量操作),用于控制内存交互过程:
注意:这八种操作必须满足以下规则:
以线程A写入共享变量x为例,完整流程如下:
若中间任一环节被阻断(如未执行store/write),则线程B无法感知A的修改,导致可见性问题——这正是volatile、synchronized等机制要解决的核心问题。
以下代码在单线程下正常,但多线程下可能陷入死循环:
public class VisibilityDemo {
private static boolean running = true;
public static void main(String[] args) {
new Thread(() -> {
while (running) {
// do work
}
System.out.println("Thread stopped.");
}).start();
try { Thread.sleep(100); } catch (InterruptedException e) {}
running = false; // 主线程修改,但子线程可能永远看不到
System.out.println("Main set running=false");
}
}问题原因:主线程修改running=false后,该值写入主内存,但子线程仍在使用工作内存中的旧值true(未重新load),导致循环无法退出。
解决方案包括:
JMM通过以下方式保障可见性:
虽然JMM未强制要求“写后立即可见”,但通过happens-before规则建立因果关系:
只要两个操作满足上述任一规则,就构成happens-before关系,后一操作可见前一操作的结果。
volatile变量具备两种特性:
注意:volatile不保证原子性!例如volatile int count = 0; count++仍非原子操作(读-改-写三步),多线程下仍会丢失更新。
误区1:volatile能替代synchronized → 错误!volatile仅保证可见性与有序性,不保证原子性。复合操作(如i++、check-then-act)仍需同步机制。
误区2:volatile变量在循环中能及时更新 → 部分正确!若循环内无其他同步操作,且JVM未做逃逸分析优化,volatile可保证可见性;但若循环体被内联优化(如HotSpot JIT),可能缓存变量值。
误区3:volatile数组能保证元素可见性 → 错误!volatile只修饰数组引用本身,数组元素修改不保证可见性。需用AtomicIntegerArray或synchronized。
场景1:状态标志 用于控制线程生命周期的布尔标志:
public class StopThread {
private static volatile boolean stopRequested;
public static void main(String[] args) throws InterruptedException {
Thread worker = new Thread(() -> {
while (!stopRequested) {
// do work
}
});
worker.start();
Thread.sleep(1000);
stopRequested = true; // 线程安全退出
}
}场景2:双重检查锁定(DCL)单例 确保实例初始化的可见性:
public class Singleton {
private static volatile Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton(); // volatile防止指令重排序
}
}
}
return instance;
}
}若无volatile,new操作可能被重排序为:分配内存→设置引用非空→执行构造器。此时另一线程可能获取未完全初始化的对象。
场景3:开销较高的初始化 如缓存加载、配置读取等一次性任务:
public class ConfigLoader {
private static volatile Config config;
public static Config getConfig() {
if (config == null) {
synchronized (ConfigLoader.class) {
if (config == null) {
config = loadConfig(); // 仅加载一次
}
}
}
return config;
}
}当线程进入synchronized块时:
当线程退出synchronized块时,其对共享变量的修改对后续获取同一锁的线程可见——这是happens-before规则中“监视器锁规则”的体现。
| 特性 | synchronized | volatile |
|---|---|---|
| 可见性 | ✅ 保证 | ✅ 保证 |
| 原子性 | ✅ 保证(临界区) | ❌ 不保证 |
| 有序性 | ✅ 保证(进入/退出屏障) | ✅ 仅禁止变量相关重排序 |
| 阻塞 | ✅ 可能阻塞线程 | ❌ 不阻塞 |
| 适用场景 | 复杂同步逻辑 | 简单状态标志/单次初始化 |
案例:非原子复合操作
public class Counter {
private int count = 0;
public void increment() {
count++; // 非原子:读→改→写
}
public int getCount() {
return count;
}
}即使count为volatile,count++仍可能丢失更新(如两个线程同时读取count=5,各自加1后都写6)。解决方案:
案例:指令重排序导致的“半初始化”对象
public class LazyInit {
private static Helper helper;
public static Helper getHelper() {
if (helper == null) {
synchronized (LazyInit.class) {
if (helper == null) {
helper = new Helper(); // 可能重排序为:分配内存→引用非空→初始化
}
}
}
return helper;
}
}若helper非volatile,另一线程可能获取未完全初始化的helper对象。修复方式:将helper声明为volatile。
| 规则名称 | 描述 | 示例 |
|---|---|---|
| 程序顺序规则 | 线程内代码按顺序执行 | x=1; y=x+1; → x=1 happens-before y=x+1 |
| 监视器锁规则 | unlock happens-before 后续lock | 线程A unlock锁;线程B lock同一锁 → A所有操作对B可见 |
| volatile变量规则 | 写happens-before 后续读 | volatile int v; A写v=1;B读v → B可见v=1 |
| 线程启动规则 | start() happens-before 线程内操作 | new Thread().start(); → 主线程所有操作对新线程可见 |
| 线程终止规则 | 线程内操作happens-before 其终止检测 | 线程A执行完;主线程join()返回 → A所有操作对主线程可见 |
| 中断规则 | interrupt() happens-before 检测 | 线程A interrupt();B检测isInterrupted() → A在中断前的操作对B可见 |
| 终结器规则 | finalize() happens-before 对象回收 | 对象finalization所有操作在回收前可见 |
happens-before关系具有传递性:若A→B且B→C,则A→C。
示例推导:
若helper非volatile,则无happens-before关系,不能保证helper.doSomething()看到完全初始化的对象。添加volatile后:
JMM通过插入内存屏障(Memory Barrier)实现happens-before语义:
例如:
对比三种单例实现的安全性:
public enum Singleton {
INSTANCE;
public void doSomething() {}
}枚举天然防反射与序列化破坏,JVM保证初始化线程安全。
public class Singleton {
private static class Holder {
private static final Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance() {
return Holder.INSTANCE;
}
}利用类加载机制:Holder类在首次调用getInstance()时加载,JVM保证类初始化的线程安全。
public class Singleton {
private static volatile Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}必须加volatile防止指令重排序,否则可能返回未完全初始化的对象。
使用ConcurrentHashMap + volatile简化缓存逻辑:
public class Cache {
private static final Map cache = new ConcurrentHashMap<>();
private static final Map loading = new ConcurrentHashMap<>();
public static Object get(String key) {
Object value = cache.get(key);
if (value != null) return value;
if (loading.putIfAbsent(key, Boolean.TRUE) == null) {
try {
value = loadFromDB(key);
cache.put(key, value);
} finally {
loading.remove(key);
}
} else {
// 等待其他线程加载完成
while (loading.containsKey(key)) {
Thread.yield();
}
}
return cache.get(key);
}
private static Object loadFromDB(String key) {
// 模拟数据库加载
return "value_" + key;
}
} 说明:
传统BlockingQueue方案:线程阻塞开销大;使用volatile + 自旋优化高频场景:
public class SpinQueue{ private volatile T item; private volatile boolean hasItem = false; public synchronized void produce(T item) { while (hasItem) { try { wait(); } catch (InterruptedException e) {} } this.item = item; hasItem = true; notifyAll(); } public synchronized T consume() { while (!hasItem) { try { wait(); } catch (InterruptedException e) {} } hasItem = false; notifyAll(); return item; } }
优化思路:若生产/消费速度接近,可用自旋替代阻塞:
public class OptimizedQueue{ private volatile T item; private volatile boolean hasItem = false; public void produce(T item) { while (!hasItem) { // 自旋等待消费 Thread.onSpinWait(); // Java 9+,提示CPU低功耗自旋 } this.item = item; hasItem = false; } public T consume() { while (hasItem) { // 自旋等待生产 Thread.onSpinWait(); } T value = item; hasItem = true; return value; } }
注意:仅适用于生产/消费速率匹配的场景,否则可能导致CPU空转。
即使i为volatile,count++仍分三步:read→add→write。多线程下可能:
最终结果为6而非7。解决方案:
关键在于内存语义:进入synchronized块时强制清空工作内存并reload主内存变量,退出时将修改同步回主内存。这确保了:
即使变量非volatile,只要通过同一把锁保护读写,即可保证可见性。
volatile只修饰数组引用本身,不修饰元素。例如:
volatile int[] arr = new int[1]; arr[0] = 10; // 元素修改不触发volatile语义
线程B读取arr[0]时可能看到旧值。正确做法:
排查步骤:
主要变化:
开发者需关注VarHandle的内存屏障语义(acquire/release/volatile等),其比Unsafe更安全且符合JMM规范。