← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识(1小时精讲内容)面试速记卡(考前30秒速看)练习题(自测)学习资料

L04 - volatile与CAS与Java内存模型

本节目标(学完能回答的面试题)

核心知识(1小时精讲内容)

一、Java内存模型(JMM)

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详解

2.1 volatile保证可见性


写volatile变量时:
  1. 将工作内存中的值刷新到主内存
  2. 使其他CPU缓存行中该变量的副本无效(MESI缓存一致性协议)

读volatile变量时:
  1. 从主内存重新加载最新值到工作内存

底层实现:
  x86架构下 → volatile写会生成 "lock addl $0x0, (%rsp)" 指令
  该指令会锁定缓存行 + 触发缓存一致性协议 + 刷新写缓冲区

2.2 volatile保证有序性(内存屏障)


四种内存屏障:

  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
  }

2.3 volatile不保证原子性


// 经典反例: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规则(重点)

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(Compare And Swap)

4.1 CAS原理


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;
}

4.2 ABA问题


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,链表损坏!)

4.3 ABA解决方案


// 方案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提供了"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的结果。

面试速记卡(考前30秒速看)

练习题(自测)

1. 用happens-before规则分析DCL单例模式:为什么不加volatile会出问题?画出重排后的执行时序。

2. 解释volatile的内存屏障插入策略:为什么写后要StoreLoad而读后不需要?

3. 编写代码验证volatile不保证原子性:100个线程各执行10000次count++,观察结果。

4. 编写代码用AtomicStampedReference解决ABA问题:创建两个线程,一个模拟ABA,一个用版本号检测。

5. 什么是伪共享?在LongAdder的Cell类中是如何解决的?(提示:@Contended或手动padding)

学习资料