java 可见性面试要点

线程 A          线程 B
  |               |
CPU缓存A        CPU缓存B
  |               |
  +---- 主内存 ----+

// 线程 B 可能永远看不到 flag 的变化
static boolean flag = false;

// 线程 A
flag = true;

// 线程 B
while (!flag) { } // 死循环

// 底层：lock 前缀指令
// 1. 将当前处理器缓存行写回内存
// 2. 使其他 CPU 缓存该地址失效（MESI 协议）

// volatile：只保证可见性
volatile int count = 0;

// synchronized：可见性 + 原子性
synchronized void increment() { count++; }

// 线程启动保证可见性
int x = 1;
new Thread(() -> {
    System.out.println(x); // 一定输出 1
}).start();

// 普通变量
int x = 1;   // 可能只写入 CPU 缓存
int y = x;   // 可能只从 CPU 缓存读

寄存器 → L1 → L2 → L3 → 主内存

volatile int[] arr = new int[10];

arr[0] = 1; // 不保证可见性！
arr = new int[20]; // 保证引用可见

AtomicIntegerArray arr = new AtomicIntegerArray(10);
arr.set(0, 1); // 保证可见性 + 原子性

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() 实际分三步：
// 1. 分配内存
// 2. 初始化对象
// 3. instance 指向内存

// 重排后可能变成 1→3→2
// 线程 B 在 3 之后、2 之前进入，拿到 null 对象的引用

// 源码
int a = 1;
int b = 2;
int c = a + b;

// 可能重排为
int b = 2;
int a = 1;
int c = a + b;

// 经典案例：DCL 单例
instance = new Singleton();
// 重排后：先赋值引用，再初始化
// 其他线程拿到未初始化对象

// 案例2：可见性问题
int x = 0, y = 0;
// 线程1        线程2
x = 1;         y = 1;
int r1 = y;    int r2 = x;
// 可能 r1=0, r2=0（都重排了）

StoreStore 屏障
volatile 写
StoreLoad 屏障

LoadLoad 屏障
volatile 读
LoadStore 屏障

// JMM 规定的 volatile 重排规则
// 1. volatile 写之前的操作，不能重排到写之后
// 2. volatile 读之后的操作，不能重排到读之前
// 3. volatile 写不能与 volatile 读重排

// volatile 写 hb 读
volatile int x;
x = 1;        // 写
int y = x;    // 读，一定看到 1

int a = 0;
volatile boolean flag = false;

// 线程 A
a = 1;           // 1
flag = true;     // 2，volatile 写
// 保证 1 在 2 之前执行

// 线程 B
if (flag) {      // 3，volatile 读
    int b = a;   // 4
    // 保证 4 能看到 a=1
}

// StoreLoad 屏障伪代码
storeStoreBarrier();
volatileWrite();
storeLoadBarrier(); // 最耗时

int x = 1;      // 原子（基本类型赋值）
x++;            // 非原子（读-改-写三步）
long y = 1L;    // 32位 JVM 上非原子

volatile int count = 0;

// 10 个线程各执行 1000 次
count++; // 非原子！

public class VolatileTest {
    private static volatile int count = 0;

    public static void main(String[] args) 
            throws InterruptedException {
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    count++;
                }
            });
            threads[i].start();
        }
        for (Thread t : threads) t.join();
        System.out.println(count); // 通常 < 10000
    }
}

synchronized void increment() { count++; }

lock.lock();
try { count++; } finally { lock.unlock(); }

AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet(); // CAS 保证原子

volatile boolean running = true;
while (running) { /* 工作 */ }

private static volatile Singleton instance;

volatile Config config;
config = loadConfig(); // 发布

volatile int temperature; // 定期更新，其他线程读取

// 标志位：volatile
volatile boolean shutdown = false;

// 计数：AtomicInteger
AtomicInteger count = new AtomicInteger(0);

// 32 位 JVM 上非原子
long x = 0;
// 线程 A         线程 B
x = 0xFFFFFFFFL;  long y = x; // 可能读到中间值

public class Config {
    final int x;
    final int y;

    public Config() {
        x = 1;
        y = 2;
    }
}

// 其他线程读到 config 引用时
// 一定能看到 x=1, y=2
Config config = new Config();

StoreStore
volatile 写
StoreLoad

LoadLoad
volatile 读
LoadStore

线程 A        线程 B
工作内存A     工作内存B
   |             |
   +--- 主内存 ---+

volatile int x = 1;
// 编译后：
// mov [x], 1
// lock addl $0, (%rsp)  ; 内存屏障

public class AtomicInteger {
    private volatile int value; // 可见性

    public final boolean compareAndSet(int expect, int update) {
        // Unsafe 的 CAS 保证原子性
        return U.compareAndSwapInt(this, VALUE, expect, update);
    }
}

private volatile int state;

volatile V val;
volatile Node<K,V> next;

private final AtomicInteger ctl = ...;
// 内部用 volatile + CAS

private transient volatile Object[] array;

volatile long x = 0; // 原子读写

volatile boolean running = true;

private static volatile Singleton instance;

volatile int count = 0;
count++; // 错误！

AtomicInteger count = new AtomicInteger(0);

AtomicBoolean、LongAdder、ConcurrentHashMap

// 轻量：volatile
volatile boolean flag;

// 重量：synchronized
synchronized (lock) { ... }

// 无锁栈（Treiber Stack）
AtomicReference<Node> top = new AtomicReference<>();

volatile 写 ≈ 解锁
volatile 读 ≈ 加锁