← 返回首页 📚 实战课程
📑 本篇章节导航 (共4章,点击直达)
一、理论篇(30%)—— JMM到内存屏障的完整链路二、动手篇(40%)—— 可验证的实验与代码三、面试模拟篇(20%)—— 追问链式考核四、练习篇(10%)

P1-04 - volatile、CAS与Java内存模型

定位:面试官问"内存屏障有哪四种""happens-before八条规则""ABA怎么解决""LongAdder为什么比AtomicLong快",你答不精确。本节专治这个gap。

一、理论篇(30%)—— JMM到内存屏障的完整链路

1.1 Java内存模型(JMM)


线程A                     主内存                    线程B
┌──────────┐         ┌───────────┐         ┌──────────┐
│ 工作内存  │ ─read─→ │  共享变量   │ ←read─ │ 工作内存  │
│ (缓存副本)│ ←write─ │  (堆内存)  │ ─write→ │ (缓存副本)│
└──────────┘         └───────────┘         └──────────┘

JMM规定:
1. 所有共享变量存储在主内存
2. 每个线程有自己的工作内存(CPU缓存/寄存器)
3. 线程不能直接读写主内存,必须通过工作内存
4. 线程间变量的传递必须经过主内存

三大特性:
- 原子性:synchronized、Lock、AtomicXxx
- 可见性:volatile、synchronized、Lock
- 有序性:volatile、happens-before

1.2 happens-before 八条规则(面试必背)

序号规则含义示例
1程序顺序规则同一线程中,前面的操作happens-before后面的操作线程内代码按顺序执行
2监视器锁规则unlock操作happens-before后续对同一锁的lock操作synchronized释放锁前的写入对下一个获取锁的线程可见
3volatile规则volatile写happens-before后续对该变量的读线程A写volatile flag,线程B读flag能看到
4线程启动规则Thread.start()happens-before该线程的所有操作主线程设置变量后start(),子线程能看到
5线程终止规则线程的所有操作happens-before该线程的join()返回子线程的修改在主线程join后可见
6线程中断规则interrupt()调用happens-before被中断线程检测到中断interrupt()后isInterrupted()能感知
7对象终结规则构造函数执行完happens-beforefinalize()对象初始化完成先于终结
8传递性A happens-before B 且 B happens-before C,则 A happens-before C多条规则组合推导

1.3 volatile 内存屏障语义


volatile写的内存屏障插入策略:
  StoreStore屏障    ← 确保之前的普通写已完成
  volatile写操作
  StoreLoad屏障     ← 确保volatile写对所有后续读可见(代价最高)

volatile读的内存屏障插入策略:
  volatile读操作
  LoadLoad屏障      ← 确保volatile读在后续读之前完成
  LoadStore屏障     ← 确保volatile读在后续写之前完成

四种内存屏障详解:
┌─────────────┬───────────────────────────────────────────┐
│  屏障类型    │  作用                                       │
├─────────────┼───────────────────────────────────────────┤
│ LoadLoad    │ Load1; LoadLoad; Load2                     │
│             │ 确保Load1在Load2之前完成                      │
├─────────────┼───────────────────────────────────────────┤
│ StoreStore  │ Store1; StoreStore; Store2                 │
│             │ 确保Store1对其他处理器可见后再执行Store2        │
├─────────────┼───────────────────────────────────────────┤
│ LoadStore   │ Load1; LoadStore; Store2                   │
│             │ 确保Load1在Store2之前完成                     │
├─────────────┼───────────────────────────────────────────┤
│ StoreLoad   │ Store1; StoreLoad; Load2                   │
│             │ 确保Store1对其他处理器可见后再执行Load2         │
│             │ (代价最高,大多数处理器都支持)                │
└─────────────┴───────────────────────────────────────────┘

volatile不能保证原子性的经典反例:


// volatile int count; count++ 不是原子操作
// count++ 实际上是三步操作:
// 1. 读 count         ← volatile保证读到最新值
// 2. count + 1        ← 这一步和下一步之间可能被其他线程插队
// 3. 写回 count
// volatile 只保证第3步的写对其他线程可见,但不保证 1-2-3 的原子性

1.4 CAS与ABA问题


CAS(compareAndSwap) 原理:
  CAS(V, Expected, New)
  如果 V == Expected,则 V = New,返回true
  否则返回false,重试(自旋)

ABA问题:
  线程1: 读到V=A → [被挂起]
  线程2: V=A→B→A  (值变了又变回来)
  线程1: CAS(A, A, C) → 成功!但中间状态被遗漏

解决方案:
  1. AtomicStampedReference(版本号,推荐)
  2. AtomicMarkableReference(布尔标记,轻量)

1.5 Unsafe类


// Unsafe 提供的 CAS 原语(JDK 9+ 通过 VarHandle 替代部分功能)
public final native boolean compareAndSwapInt(
    Object o, long offset, int expected, int x);

// AtomicInteger 的 incrementAndGet() 底层就是Unsafe CAS:
public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

// unsafe.getAndAddInt 源码:
public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        v = getIntVolatile(o, offset);   // volatile读最新值
    } while (!compareAndSwapInt(o, offset, v, v + delta)); // CAS自旋
    return v;
}

1.6 LongAdder vs AtomicLong


AtomicLong:
  所有线程对同一个value做CAS,高并发时竞争激烈,自旋消耗CPU

LongAdder(分段累加,Striped64):
  基础值 base + Cell[] 数组(分段累加)
  不同线程hash到不同的Cell,减少竞争
  sum()时 = base + 所有Cell的value

  结构:
  ┌───────┐
  │ base   │ ← 低竞争时直接CAS到base
  └───────┘
  ┌────┬────┬────┬────┐
  │Cell│Cell│Cell│Cell│ ← 高竞争时分散到不同Cell(分段锁思想)
  │ 0  │ 1  │ 2  │ 3  │
  └────┴────┴────┴────┘
  每个Cell内部用 @sun.misc.Contended 避免伪共享(缓存行填充)

  Cell数组初始容量:2(懒初始化)
  扩容条件:竞争失败且未达到CPU核心数
  sum()精度:非精确(遍历Cell期间可能有新写入)
  适用场景:高并发计数(如统计QPS、性能监控),不需要精确值

二、动手篇(40%)—— 可验证的实验与代码

2.1 happens-before违规与volatile修复


/**
 * 实验1:可见性问题 —— 没有volatile时的死循环
 *
 * 现象:主线程修改了flag,但工作线程可能永远读不到新值
 * 原因:JIT可能将while(!flag)优化为if(!flag) while(true)
 *
 * 验证方法:
 *   场景A:flag不加volatile → 运行后工作线程大概率不退出
 *   场景B:flag加volatile → 工作线程立即感知flag变化并退出
 */
public class VisibilityDemo {

    // 场景A:不加volatile,可能死循环
    // static boolean flag = false;

    // 场景B:加volatile,保证可见
    static volatile boolean flag = false;

    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            System.out.println("工作线程启动,等待flag=true...");
            while (!flag) {
                // 空循环,不做任何事
                // 没有volatile时,JIT可能优化掉flag的读取
            }
            System.out.println("工作线程退出!flag=" + flag);
        }).start();

        Thread.sleep(1000);
        flag = true; // 主线程修改flag
        System.out.println("主线程设置flag=true");

        Thread.sleep(2000);
        System.out.println("主线程结束");
    }
}

2.2 指令重排验证(DCL单例模式)


/**
 * 实验2:volatile防止指令重排 —— 双重检查锁定(DCL)
 *
 * 为什么需要volatile?
 * instance = new Singleton() 实际分三步:
 *   1. 分配内存空间
 *   2. 初始化对象(调用构造方法)
 *   3. 将引用指向内存地址
 *
 * 重排可能变成 1→3→2:
 *   线程A执行到3(引用非null但对象未初始化)
 *   线程B判断instance!=null,直接返回了一个半初始化的对象!
 *
 * volatile通过StoreStore屏障确保1→2→3不被重排
 */
public class DoubleCheckLockDemo {

    // 没有volatile,极端情况下可能拿到未初始化完成的对象
    private static volatile DoubleCheckLockDemo instance;

    private DoubleCheckLockDemo() {
        System.out.println("构造方法被调用,线程=" + Thread.currentThread().getName());
    }

    public static DoubleCheckLockDemo getInstance() {
        if (instance == null) {                 // 第一次检查(不加锁)
            synchronized (DoubleCheckLockDemo.class) {
                if (instance == null) {         // 第二次检查(加锁后)
                    instance = new DoubleCheckLockDemo();
                    // volatile确保 1→2→3 不会重排为 1→3→2
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                DoubleCheckLockDemo obj = getInstance();
                System.out.println(Thread.currentThread().getName() +
                    " 获取实例: " + obj.hashCode());
            }, "Thread-" + i).start();
        }
    }
}

2.3 CAS操作与ABA问题演示


import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * 实验3:ABA问题及解决方案
 *
 * 运行结果:
 *   ABA问题部分:T1的CAS(100→200)成功,但中间值经历了变化
 *   ABA解决部分:T1的CAS失败,因为版本号不匹配
 */
public class CASandABADemo {

    // ========== ABA问题演示 ==========
    static void abaProblem() throws Exception {
        AtomicInteger ai = new AtomicInteger(100);

        Thread t1 = new Thread(() -> {
            int old = ai.get();
            System.out.println("T1: 读到值=" + old);
            try { Thread.sleep(1000); } catch (Exception e) {}
            boolean success = ai.compareAndSet(100, 200);
            System.out.println("T1: CAS(100→200) " + (success ? "成功" : "失败") +
                ",当前值=" + ai.get());
        });

        Thread t2 = new Thread(() -> {
            ai.compareAndSet(100, 101);  // 100→101
            System.out.println("T2: 100→101,当前值=" + ai.get());
            ai.compareAndSet(101, 100);  // 101→100(ABA!)
            System.out.println("T2: 101→100,当前值=" + ai.get());
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }

    // ========== 用AtomicStampedReference解决ABA ==========
    static void abaSolution() throws Exception {
        AtomicStampedReference<Integer> ref =
            new AtomicStampedReference<>(100, 1); // 初始值100,版本号1

        Thread t1 = new Thread(() -> {
            int stamp = ref.getStamp();
            Integer old = ref.getReference();
            System.out.println("T1: 读到值=" + old + ",版本=" + stamp);
            try { Thread.sleep(1000); } catch (Exception e) {}
            boolean success = ref.compareAndSet(old, 200, stamp, stamp + 1);
            System.out.println("T1: CAS(100→200, 版本" + stamp + "→" + (stamp+1) + ") " +
                (success ? "成功" : "失败"));
        });

        Thread t2 = new Thread(() -> {
            int stamp = ref.getStamp();
            ref.compareAndSet(100, 101, stamp, stamp + 1);
            System.out.println("T2: 100→101,版本=" + ref.getStamp());
            ref.compareAndSet(101, 100, ref.getStamp(), ref.getStamp() + 1);
            System.out.println("T2: 101→100,版本=" + ref.getStamp());
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }

    public static void main(String[] args) throws Exception {
        System.out.println("===== ABA问题 =====");
        abaProblem();
        System.out.println("\n===== ABA解决方案 =====");
        abaSolution();
    }
}

2.4 LongAdder vs AtomicLong 性能对比


import java.util.concurrent.*;
import java.util.concurrent.atomic.*;

/**
 * 实验4:LongAdder vs AtomicLong 高并发计数性能对比
 *
 * 典型运行结果(16线程,每线程100万次递增):
 *   AtomicLong: ~800ms
 *   LongAdder:  ~80ms
 *   LongAdder快约10倍
 *
 * 原因:LongAdder用Cell数组分散竞争,减少CAS自旋
 */
public class LongAdderBenchmark {

    static final int THREADS = 16;
    static final int OPS_PER_THREAD = 1_000_000;

    public static void main(String[] args) throws Exception {
        // 预热
        System.out.println("预热中...");
        benchAtomicLong();
        benchLongAdder();

        System.out.println("\n===== AtomicLong =====");
        long t1 = benchAtomicLong();

        System.out.println("\n===== LongAdder =====");
        long t2 = benchLongAdder();

        System.out.println("\n===== 结果 =====");
        System.out.println("AtomicLong: " + t1 + "ms");
        System.out.println("LongAdder:  " + t2 + "ms");
        System.out.println("LongAdder 快 " + (t1 * 100 / t2) + "%");
    }

    static long benchAtomicLong() throws Exception {
        AtomicLong al = new AtomicLong(0);
        CountDownLatch latch = new CountDownLatch(THREADS);

        long start = System.currentTimeMillis();
        for (int i = 0; i < THREADS; i++) {
            new Thread(() -> {
                for (int j = 0; j < OPS_PER_THREAD; j++) {
                    al.incrementAndGet();  // 所有线程竞争同一个value
                }
                latch.countDown();
            }).start();
        }
        latch.await();
        long cost = System.currentTimeMillis() - start;
        System.out.println("结果: " + al.get() + " (期望" +
            (THREADS * OPS_PER_THREAD) + ")");
        return cost;
    }

    static long benchLongAdder() throws Exception {
        LongAdder la = new LongAdder();
        CountDownLatch latch = new CountDownLatch(THREADS);

        long start = System.currentTimeMillis();
        for (int i = 0; i < THREADS; i++) {
            new Thread(() -> {
                for (int j = 0; j < OPS_PER_THREAD; j++) {
                    la.increment();  // 分散到不同Cell,减少竞争
                }
                latch.countDown();
            }).start();
        }
        latch.await();
        long cost = System.currentTimeMillis() - start;
        System.out.println("结果: " + la.sum() + " (期望" +
            (THREADS * OPS_PER_THREAD) + ")");
        return cost;
    }
}

2.5 Unsafe类直接操作内存


import sun.misc.Unsafe;
import java.lang.reflect.Field;

/**
 * 实验5:通过反射获取Unsafe实例,演示CAS操作
 *
 * 注意:JDK 9+ 推荐使用 VarHandle 替代 Unsafe
 */
public class UnsafeDemo {

    private static final Unsafe unsafe;
    private static final long valueOffset;

    private volatile int value = 0;

    static {
        try {
            // 通过反射获取Unsafe实例(getUnsafe()会检查ClassLoader)
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            unsafe = (Unsafe) f.get(null);
            valueOffset = unsafe.objectFieldOffset(
                UnsafeDemo.class.getDeclaredField("value"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }

    public void casIncrement() {
        int old;
        do {
            old = unsafe.getIntVolatile(this, valueOffset);
        } while (!unsafe.compareAndSwapInt(this, valueOffset, old, old + 1));
    }

    public static void main(String[] args) throws Exception {
        UnsafeDemo demo = new UnsafeDemo();

        System.out.println("初始值: " + demo.value);
        boolean success = unsafe.compareAndSwapInt(demo, valueOffset, 0, 42);
        System.out.println("CAS(0→42): " + success + ",当前值=" + demo.value);

        success = unsafe.compareAndSwapInt(demo, valueOffset, 0, 99);
        System.out.println("CAS(0→99): " + success + ",当前值=" + demo.value);

        // 多线程CAS自增
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    demo.casIncrement();
                }
            });
            threads[i].start();
        }
        for (Thread t : threads) t.join();
        System.out.println("10线程各增1000次,结果=" + demo.value + "(期望10042)");
    }
}

三、面试模拟篇(20%)—— 追问链式考核

Q1: volatile能保证线程安全吗?


Q1.1: volatile能保证可见性和有序性,为什么不能保证原子性?
→ volatile只保证读写操作的可见性
→ i++不是原子操作(读→改→写三步),volatile不能把三步合成一步
→ 需要原子性时用synchronized或AtomicInteger

Q1.2: 那什么场景下volatile就够了?
→ 一个线程写,多个线程读(状态标志位)
→ DCL单例模式(防止指令重排)
→ 结合CAS使用(AtomicInteger内部就是volatile + CAS)

Q1.3: volatile和synchronized的区别?
→ volatile是轻量级同步,不引起线程上下文切换
→ synchronized是重量级同步,会阻塞
→ volatile只能用于修饰变量,synchronized可修饰方法和代码块

Q2: 请解释happens-before规则


Q2.1: happens-before和"时间上先发生"是一个意思吗?
→ 不是。happens-before是JMM定义的偏序关系
→ 一个操作A happens-before B,不意味着A在时间上先于B执行
→ 而是JMM保证A的结果对B可见

Q2.2: 请用happens-before推导DCL单例为什么安全
→ 1. 程序顺序:构造函数中的赋值 HB于 写volatile变量instance
→ 2. volatile规则:写volatile HB于 后续读volatile
→ 3. 程序顺序:读volatile HB于 使用instance的字段
→ 4. 传递性:构造函数赋值 HB于 使用instance字段
→ 所以线程B读instance时,构造函数一定已经完成

Q2.3: synchronized的happens-before是怎么保证的?
→ 线程A释放锁之前的所有写操作,对线程B获取同一锁后可见
→ monitor规则:unlock HB于 后续lock

Q3: CAS有什么缺点?


Q3.1: 自旋CAS如果长时间不成功会怎样?
→ 会消耗CPU(空转)
→ 高并发下自旋次数增多,性能下降
→ 解决方案:LongAdder的分散策略,或改用锁

Q3.2: ABA问题在实际开发中真的会遇到吗?
→ 大部分场景不关心ABA(如计数器)
→ 但有些场景关心:栈的ABA(引用指向变了又变回,但栈结构已变)
→ 解决:AtomicStampedReference加版本号

Q3.3: CAS只能保证一个共享变量的原子操作,多个怎么办?
→ 1. 用锁(synchronized/Lock)
→ 2. 把多个变量封装成一个对象,用AtomicReference
→ 3. JDK 9+ 用VarHandle

常见踩坑

1. 以为volatile变量做i++是安全的 —— 不是,i++ = 读+改+写三步

2. 以为volatile对象引用变了,对象内部字段也可见 —— 错,只保证引用本身的可见性

3. 以为happens-before就是时间顺序 —— 错,是可见性保证的偏序关系

4. 以为AtomicLong和synchronized性能差不多 —— 低竞争时Atomic更快,高竞争时都不好

5. 在DCL单例中忘记volatile —— JDK 5+用volatile解决指令重排


四、练习篇(10%)

练习1:验证指令重排

编写程序,两个线程分别执行:

循环执行100万次,观察是否出现flag==true但x==0的情况。

练习2:手写简化版AtomicInteger

只用Unsafe的compareAndSwapInt和getIntVolatile,手写一个支持get/set/incrementAndGet/compareAndSet的类。

练习3:LongAdder源码分析

阅读LongAdder源码,回答:

练习4:线程间通信的五种方式

分别用以下方式实现"线程A执行完再执行线程B":

1. volatile + 自旋

2. synchronized + wait/notify

3. CountDownLatch

4. CompletableFuture

5. BlockingQueue

对比五种方式的优缺点和适用场景。