Java内存模型(Java Memory Model,JMM)是Java并发编程的基石,它定义了线程如何与主内存交互,以及多线程环境下变量可见性、原子性与有序性的根本保障机制。JMM并非真实存在的物理内存结构,而是一组抽象规则,用于规范Java虚拟机在多线程并发执行时对共享变量的读写行为。
JMM的核心目标是解决并发编程中的三大经典问题:可见性(Visibility)、原子性(Atomicity)与有序性(Ordering)。这三者共同构成了线程安全的理论基础。例如,一个线程修改了共享变量,其他线程是否能立即看到该修改?两个操作是否能被拆分为不可分割的最小单位?指令是否可能被编译器或处理器重排序导致逻辑异常?JMM通过一系列内存屏障、happens-before规则与内存交互操作来回答这些问题。
JMM将内存划分为主内存(Main Memory)与工作内存(Working Memory)。每个线程拥有独立的工作内存,其中保存了该线程使用的变量的副本(从主内存拷贝而来)。线程对变量的所有操作(读取、赋值等)必须在工作内存中进行,不能直接读写主内存中的变量。不同线程之间无法直接访问彼此的工作内存,变量值的传递需通过主内存完成,这正是可见性问题的根源。
以如下代码为例:
public class VisibilityDemo {
static boolean flag = false;
public static void main(String[] args) {
new Thread(() -> {
System.out.println("线程A准备就绪...");
while (!flag) {
// 空循环等待
}
System.out.println("线程A检测到flag变为true,退出循环");
}, "A").start();
try { Thread.sleep(100); } catch (InterruptedException e) {}
new Thread(() -> {
System.out.println("线程B设置flag为true");
flag = true;
}, "B").start();
}
}
在JMM语义下,线程B修改flag后,若未使用同步机制(如synchronized、volatile),线程A可能永远看不到该修改,因为其工作内存中flag仍为false缓存值。JMM通过volatile关键字可强制将写操作立即刷新至主内存,并使其他线程中该变量的缓存失效,从而保障可见性。
JMM还规定了八种内存交互操作:lock(锁定)、unlock(解锁)、read(读取)、load(载入)、use(使用)、assign(赋值)、store(存储)、write(写入)。这些操作必须满足原子性、可见性与有序性约束。例如,read与load、store与write必须成对出现;对long与double的非volatile读写,在32位JVM上可能非原子(但现代JVM普遍已实现原子性)。理解这些操作是掌握JMM的关键。
值得注意的是,JMM不保证所有操作天然线程安全。例如,i++看似单行,实则包含读取→计算→写入三步,属于复合操作,在多线程下必然产生竞态条件(Race Condition)。必须借助synchronized、AtomicInteger或显式锁(ReentrantLock)保障原子性。
volatile是JMM中轻量级的同步机制,其作用有二:保障可见性与禁止指令重排序,但不保证原子性。当变量被声明为volatile后,其写操作会立即刷新到主内存,且读操作会强制从主内存获取最新值,绕过工作内存缓存。
典型应用之一是状态标志位。例如线程间通信:
public class StopThread {
private static volatile boolean running = true;
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
while (running) {
// 执行任务
}
System.out.println("线程已停止");
});
t.start();
Thread.sleep(100);
running = false; // 主线程修改标志
t.join();
}
}
若去掉volatile,主线程修改running后,工作线程可能因缓存未刷新而无限循环。添加volatile后,工作线程每次循环都会重新读取主内存中的flag值,从而正确退出。
然而,volatile无法解决复合操作的原子性问题。例如:
public class Counter {
private static volatile int count = 0;
public static void increment() {
count++; // 非原子操作!
}
}
尽管count是volatile,但count++包含三次内存操作:读取旧值→加1→写回新值。在多线程下,两个线程可能同时读到count=5,各自加1后都写回6,导致丢失更新。此时必须使用AtomicInteger或synchronized。
volatile的适用场景需同时满足:
① 对变量的写操作不依赖当前值(即无复合操作);
② 该变量不会与其他状态变量共同参与不变性条件(如“count > 0”);
③ 读操作可接受陈旧值(如日志级别、配置开关)。
若任一条件不满足,volatile将失效。
happens-before是JMM中定义操作间可见性的核心规则。它是一种偏序关系,若A happens-before B,则A操作的执行结果对B可见。注意:它不保证执行顺序,只保证内存可见性。
JMM定义了八条happens-before规则:
看一个经典案例:
public class HappensBeforeDemo {
private static int data;
private static volatile boolean ready;
public static void writer() {
data = 42; // ①
ready = true; // ② volatile写
}
public static void reader() {
if (ready) { // ③ volatile读
System.out.println(data); // ④
}
}
}
根据volatile变量规则,② h-b ③;再由程序次序规则,① h-b ②,③ h-b ④;结合传递性,① h-b ④,因此④读到的data必为42。若ready非volatile,则②与③之间无happens-before关系,④可能读到旧值0。
许多开发者误以为“synchronized只保证原子性”,其实它同时保障可见性与有序性。每次进入synchronized块前会清空工作内存,从主内存load最新值;退出时将工作内存数据flush回主内存。这正是监视器锁规则的体现。
JMM通过内存屏障(Memory Barrier)实现有序性保障。内存屏障是一组CPU指令,用于:
① 阻止屏障两侧指令重排序;
② 强制刷出CPU缓存,保证内存可见性;
③ 实现特定平台下的内存一致性(如x86的SFence/LFence/MFence)。
Java中常见屏障类型:
• LoadLoad屏障:确保load1在load2前完成
• StoreStore屏障:确保store1在store2前刷新
• LoadStore屏障:确保load在store前完成
• StoreLoad屏障:防止store与后续load重排序(最重,常用于volatile读写)
以volatile写为例,JMM要求在volatile写后插入StoreStore+StoreLoad屏障;volatile读前插入LoadLoad+LoadStore屏障。这使得volatile变量的读写具备类似“内存 fence”的效果。
看一个重排序案例:
public class ReorderDemo {
static int x = 0, y = 0;
public static void main(String[] args) throws InterruptedException {
Thread a = new Thread(() -> {
x = 1; // 操作1
y = 1; // 操作2
});
Thread b = new Thread(() -> {
if (y == 0) { // 操作3
System.out.println("x = " + x); // 操作4
}
});
a.start(); b.start();
a.join(); b.join();
}
}
在单线程中,若y=1,必有x=1;但在多线程下,由于指令重排序,可能先执行y=1,再执行x=1,此时线程b检测到y=0,直接输出x=0(未被x=1影响)。这违反了直觉,但JMM允许——除非使用volatile或synchronized禁止重排序。
JMM对volatile、synchronized、final等关键字生成的字节码指令会自动插入内存屏障。例如,volatile int v;在写入时编译器会插入StoreStore+StoreLoad屏障,确保屏障前的所有写操作先于v的写入完成。
指令重排序分为三类:
① 编译器优化重排序: javac将字节码重排;
② 指令级并行重排序: CPU将指令乱序执行(如pipelining);
③ 内存系统重排序: 缓存与写缓冲区导致写操作延迟可见。
JMM抽象出“as-if-serial”语义:单线程下,无论怎么重排序,程序执行结果不变。但多线程下,重排序可能破坏线程间可见性。
经典双重检查锁定单例模式曾因重排序出错:
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;
}
}
new Singleton()在JVM中实际分解为:
① 分配内存;
② 调用构造函数;
③ 将引用指向内存地址。
若发生重排序(①→③→②),线程A执行到③时,instance非空但未初始化完成;此时线程B调用getInstance(),检测到instance≠null,直接返回未初始化对象,导致空指针或数据异常。添加volatile后,禁止③与②重排序,确保对象完全初始化后才赋值。
Java 5后,volatile语义增强,禁止了volatile变量的读写与前后指令的重排序(但非完全禁止所有重排序)。synchronized块则禁止其内部所有重排序与外部交互。final字段在构造器中初始化后,对其他线程可见(需通过正确发布),因JMM保证final字段写happens-before构造器结束。
线程安全等级可划分为五层:
① 不可变(Immutable):String、Integer等final类,天然线程安全;
② 绝对线程安全:如CopyOnWriteArrayList,任何操作都无需外部同步;
③ 相对线程安全:Vector、Hashtable,单次操作线程安全,但复合操作仍需同步;
④ 接口线程安全:Collections.synchronizedList等包装类;
⑤ 线程非安全:ArrayList、HashMap等。
常见线程安全技术:
• 互斥同步:synchronized、ReentrantLock(悲观锁)
• 非阻塞同步:CAS(Compare-And-Swap) + 自旋(AtomicInteger)
• 无同步方案:线程本地存储(ThreadLocal)、可重入代码(Reentrant Code)
• 共享不可变:使用final、Collections.unmodifiableXXX()
看一个ThreadLocal案例:
public class ThreadLocalDemo {
private static final ThreadLocal threadLocal = ThreadLocal.withInitial(() -> 0);
public static void main(String[] args) {
IntStream.range(0, 3).forEach(i -> new Thread(() -> {
threadLocal.set(i * 10);
System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());
}, "T" + i).start());
}
}
输出为T0:0、T1:10、T2:20,各线程互不影响。ThreadLocal通过为每个线程维护独立副本实现隔离,本质是空间换时间。
ReentrantLock比synchronized更灵活,支持公平锁、可中断锁、超时锁、多条件变量。例如:
Lock lock = new ReentrantLock(true); // 公平锁
lock.lock();
try {
// 临界区
} finally {
lock.unlock();
}
公平锁确保等待时间最长的线程优先获取锁,减少线程饥饿,但吞吐量略低。synchronized是非公平锁,性能更高。
误区一:“volatile能替代synchronized”
→ 错。volatile仅保障可见性与有序性,不保证原子性。复合操作仍需锁。
误区二:“synchronized是重量级锁,应避免使用”
→ 过时。Java 6后synchronized引入偏向锁、轻量级锁、自适应自旋,性能大幅提升。在竞争不激烈时,synchronized甚至优于ReentrantLock。
误区三:“final字段可在线程间安全共享”
→ 需满足发布条件!若对象引用在构造器中逸出(如this传入其他线程),final字段可能不可见。正确方式是通过构造器完成后再发布引用。
误区四:“AtomicInteger能保证复合操作原子性”
→ 仅单变量操作原子(如getAndIncrement)。若逻辑涉及多个Atomic变量(如a++ && b--),需用锁或AtomicReference包装对象。
实战建议:
• 优先使用不可变对象与线程本地变量;
• 复合操作用synchronized或显式锁;
• 状态标志用volatile;
• 高并发计数用LongAdder(比AtomicLong更优);
• 避免过度同步:缩小锁范围、减少锁持有时间。
JMM正式确立:JSR-133规范发布,引入volatile语义增强、happens-before规则,修复旧版内存模型缺陷。
synchronized优化:引入偏向锁(Biased Locking)与轻量级锁,大幅降低锁竞争开销。
LongAdder诞生:为高并发计数场景设计,通过分段CAS替代单一AtomicInteger,显著提升吞吐量。
结构化并发提案(JEP 428):引入StructuredTaskScope,简化多任务协同,减少显式线程管理。
| 特性 | volatile | synchronized | final |
|---|---|---|---|
| 可见性 | ✓ | ✓ | ✓(需正确发布) |
| 原子性 | ✗ | ✓ | ✓(构造器内) |
| 有序性 | ✓(禁止部分重排序) | ✓(禁止内部重排序) | ✓ |
| 阻塞性 | ✗ | ✓ | ✗ |
| 适用场景 | 状态标志、单次发布 | 复合操作、临界区 | 不可变对象 |
volatile Singleton instance;public enum Singleton { INSTANCE; }深入理解Java内存模型是编写高并发程序的前提。从volatile的可见性保障,到happens-before的语义规则,再到内存屏障对重排序的控制,每一层都紧密关联着线程安全的实现。开发者应避免“经验主义”,通过理解底层原理选择正确工具:不可变优先、同步最小化、工具专业化。
最后提醒:JMM是Java并发编程的“宪法”,但不是银弹。它无法替代良好的架构设计与代码规范。在实际项目中,应结合业务场景权衡性能与安全性,让并发程序既高效又可靠。