JMM(Java Memory Model)定义了多线程环境下共享变量的访问规则,是一种抽象规范。
JMM三大特性:
| 特性 | 含义 | 保证手段 |
|---|---|---|
| 可见性 | 一个线程修改共享变量后,其他线程能立即看到 | volatile、synchronized、final |
| 有序性 | 程序执行顺序符合预期(防止指令重排) | volatile、happens-before |
| 原子性 | 操作不可分割,要么全部成功要么全部失败 | synchronized、Lock、Atomic类 |
JMM抽象结构:
┌─────────────────────────────────────────────────────────────┐
│ JMM 抽象模型 │
├─────────────────────────────────────────────────────────────┤
│ │
│ Thread A 主内存 Thread B │
│ ┌──────┐ ┌──────────┐ ┌──────┐ │
│ │ │ read ←──── │ │ ────→ read │ │ │
│ │ 工作 │ ────→ write │ 共享变量 │ write ←─── │ 工作 │ │
│ │ 内存 │ │ (Heap) │ │ 内存 │ │
│ │ │ load ←──── │ │ ────→ load │ │ │
│ │ │ ────→ store │ │ store ←─── │ │ │
│ └──────┘ └──────────┘ └──────┘ │
│ │
│ JMM定义了8种原子操作: │
│ lock, unlock, read, load, use, assign, store, write │
│ │
└─────────────────────────────────────────────────────────────┘
问题根源:每个线程有自己的工作内存(CPU缓存抽象),对共享变量的修改可能停留在工作内存中,未及时刷新到主内存,导致其他线程读到旧值。
写volatile变量时:
1. 将工作内存中的值刷新到主内存
2. 使其他CPU缓存行中该变量的副本无效(MESI缓存一致性协议)
读volatile变量时:
1. 从主内存重新加载最新值到工作内存
底层实现:
x86架构下 → volatile写会生成 "lock addl $0x0, (%rsp)" 指令
该指令会锁定缓存行 + 触发缓存一致性协议 + 刷新写缓冲区
四种内存屏障:
LoadLoad: Load1; LoadLoad; Load2
→ Load2及后续读不会被重排到Load1之前
StoreStore: Store1; StoreStore; Store2
→ Store1及之前的写对其他处理器可见后,才执行Store2
LoadStore: Load1; LoadStore; Store2
→ Store2不会被重排到Load1之前
StoreLoad: Store1; StoreLoad; Load2
→ Load2不会被重排到Store1之前(全能屏障,开销最大)
volatile的内存屏障插入策略:
volatile写操作前:插入 StoreStore 屏障
volatile写操作后:插入 StoreLoad 屏障
volatile读操作前:(无)
volatile读操作后:插入 LoadLoad 屏障 + LoadStore 屏障
示例:
// 线程A
x = 1; // 普通写
StoreStoreBarrier // 确保x=1对其他线程可见后,再写volatile
volatileFlag = true; // volatile写
StoreLoadBarrier // 确保volatile写对其他线程可见后,再读
// 线程B
if (volatileFlag) { // volatile读
LoadLoadBarrier // 确保读flag后,后续读不会重排到前面
LoadStoreBarrier // 确保读flag后,后续写不会重排到前面
int y = x; // 普通读,保证读到x=1
}
// 经典反例:volatile int计数器
volatile int count = 0;
// 100个线程各执行1000次 count++
// 结果远小于100000!因为 count++ 不是原子操作
// count++ 实际分为3步:
// 1. 读取count值(从主内存读最新值 ✓)
// 2. count + 1(在工作内存中计算)
// 3. 写回count(写回主内存 ✓)
// 步骤2→3之间可能被其他线程抢占!
// 解决方案:
// 1. synchronized
// 2. AtomicInteger(CAS)
// 3. LongAdder(分段CAS)
happens-before是JMM提供的"可见性保证":如果A happens-before B,那么A的操作结果对B可见。
8条happens-before规则:
1. 程序顺序规则:同一线程中,前面的操作 happens-before 后面的操作
(注意:这不意味着不能重排,只是重排后结果要等价于顺序执行)
2. volatile变量规则:volatile写 happens-before 后续对该变量的读
3. 锁规则:unlock操作 happens-before 后续对同一锁的lock操作
4. 传递性:A hb B, B hb C → A hb C
5. 线程启动规则:Thread.start() happens-before 该线程的所有操作
6. 线程终止规则:线程的所有操作 happens-before Thread.join()返回
7. 线程中断规则:interrupt() happens-before 被中断线程检测到中断
8. 对象终结规则:构造方法执行完 happens-before finalize()
happens-before分析实战:
// 经典DCL单例模式分析
class Singleton {
private volatile static Singleton instance; // 必须volatile!
public static Singleton getInstance() {
if (instance == null) { // ① 第一次检查
synchronized (Singleton.class) { // ② 加锁
if (instance == null) { // ③ 第二次检查
instance = new Singleton(); // ④ 创建实例
}
}
}
return instance;
}
}
// 为什么必须volatile?
// new Singleton() 实际分3步:
// a. 分配内存空间
// b. 初始化对象(调用构造方法)
// c. 将引用指向内存地址
//
// JVM可能重排为 a → c → b(b和c无依赖)
// 如果线程A执行到c(引用非null但对象未初始化)
// 线程B在①处判断instance != null,直接返回未初始化的对象!
//
// volatile写有StoreStore屏障,保证 a→b→c 的顺序执行
CAS(V, Expected, New)
V → 内存中的值
Expected → 期望值(旧值)
New → 新值
逻辑:
if (V == Expected) {
V = New; // 更新成功
return true;
} else {
return false; // 更新失败(被其他线程修改了)
}
整个操作是原子的(CPU指令级别,x86用 cmpxchg 指令)
// AtomicInteger CAS操作示例
AtomicInteger count = new AtomicInteger(0);
// incrementAndGet 源码(JDK 9+ VarHandle)
public int incrementAndGet() {
return U.getAndAddInt(this, VALUE, 1) + 1;
}
// Unsafe.getAndAddInt(自旋CAS)
public final int getAndAddInt(Object o, long offset, int delta) {
int v;
do {
v = getIntVolatile(o, offset); // 读取当前值
} while (!compareAndSwapInt(o, offset, v, v + delta)); // CAS失败就重试
return v;
}
ABA问题:
线程1:读取 V=A
线程2:V=A → B → A(改了又改回来)
线程1:CAS(A, A, C) 成功!
→ 线程1不知道V被修改过,CAS"被骗"了
示例(链表ABA):
栈: A → B → C
线程1要弹出A,保存了head=A, next=B
线程2弹出A, 弹出B, 又把A push回去
栈: A → C
线程1 CAS(head, A, B) 成功
栈: B → ???(B.next可能指向已删除的C,链表损坏!)
// 方案1:AtomicStampedReference(版本号)
AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 1);
// 更新时带上版本号
int stamp = ref.getStamp();
ref.compareAndSet("A", "B", stamp, stamp + 1);
// CAS时同时比较值和版本号
// A(1) → B(2) → A(3) → 线程1期望A(1),但实际是A(3),CAS失败!
// 方案2:AtomicMarkableReference(布尔标记)
// 不需要计数,只需要知道"是否被修改过"
AtomicMarkableReference<String> ref = new AtomicMarkableReference<>("A", false);
// Unsafe提供了"unsafe"的底层操作(JDK 9+建议用VarHandle替代)
// 但理解Unsafe对理解并发框架很重要
Unsafe unsafe = Unsafe.getUnsafe(); // 只能在Bootstrap ClassLoader中使用
// CAS操作
boolean compareAndSwapInt(Object o, long offset, int expected, int x);
boolean compareAndSwapLong(Object o, long offset, long expected, long x);
boolean compareAndSwapObject(Object o, long offset, Object expected, Object x);
// 内存屏障
void storeFence(); // StoreStore + StoreLoad
void loadFence(); // LoadLoad + LoadStore
void fullFence(); // 全能屏障
// 线程挂起/唤醒(LockSupport底层)
void park(boolean isAbsolute, long time);
void unpark(Object thread);
// 内存操作
long objectFieldOffset(Field f); // 获取字段偏移量
Object getObjectVolatile(Object o, long offset);
void putObjectVolatile(Object o, long offset, Object x);
// JDK 9+ VarHandle替代方案
VarHandle VH_STATE = MethodHandles.lookup()
.findVarHandle(MyClass.class, "state", int.class);
VH_STATE.compareAndSet(this, 0, 1); // 和Unsafe的CAS等效
| 机制 | 可见性 | 有序性 | 原子性 | 适用场景 |
|---|---|---|---|---|
| volatile | 是 | 是(内存屏障) | 否(单次读写是原子的) | 状态标志位、DCL单例 |
| CAS | 是 | 是 | 是(CPU指令级原子) | 计数器、Atomic类 |
| synchronized | 是 | 是 | 是 | 复合操作临界区 |
| Lock | 是 | 是 | 是 | 需要高级特性的场景 |
Q1: volatile和synchronized的区别?
volatile是轻量级同步,只保证可见性和有序性,不保证原子性。synchronized是重量级同步,三者都保证。volatile不会阻塞线程,synchronized会。volatile只能修饰变量,synchronized可修饰方法和代码块。
Q2: 为什么volatile读比volatile写便宜?
volatile写需要StoreStore+StoreLoad两个屏障(StoreLoad是全能屏障,开销大);volatile读只需要LoadLoad+LoadStore两个轻量屏障。
Q3: CAS有什么缺点?
(1) 自旋开销:CAS长时间失败会空耗CPU;(2) 只能保证单个变量的原子操作(AtomicReference可解决单引用,AtomicIntegerFieldUpdater可解决对象的单个字段);(3) ABA问题(用版本号解决)。
Q4: 伪共享(False Sharing)是什么?怎么解决?
CPU缓存以缓存行(通常64字节)为单位,如果两个volatile变量在同一缓存行中,一个线程修改变量A会使另一个线程的变量B缓存失效,即使两者逻辑无关。解决方案:@Contended注解(JDK 8+)、手动填充padding。
Q5: happens-before和"时间上的先发生"是同一回事吗?
不是。happens-before是JMM的可见性保证规则,不是时间顺序。一个操作happens-before另一个,不意味着前者在时间上先发生。但如果A在时间上先于B,且没有happens-before关系,B可能看不到A的结果。
1. 用happens-before规则分析DCL单例模式:为什么不加volatile会出问题?画出重排后的执行时序。
2. 解释volatile的内存屏障插入策略:为什么写后要StoreLoad而读后不需要?
3. 编写代码验证volatile不保证原子性:100个线程各执行10000次count++,观察结果。
4. 编写代码用AtomicStampedReference解决ABA问题:创建两个线程,一个模拟ABA,一个用版本号检测。
5. 什么是伪共享?在LongAdder的Cell类中是如何解决的?(提示:@Contended或手动padding)