定位:面试官问"内存屏障有哪四种""happens-before八条规则""ABA怎么解决""LongAdder为什么比AtomicLong快",你答不精确。本节专治这个gap。
线程A 主内存 线程B
┌──────────┐ ┌───────────┐ ┌──────────┐
│ 工作内存 │ ─read─→ │ 共享变量 │ ←read─ │ 工作内存 │
│ (缓存副本)│ ←write─ │ (堆内存) │ ─write→ │ (缓存副本)│
└──────────┘ └───────────┘ └──────────┘
JMM规定:
1. 所有共享变量存储在主内存
2. 每个线程有自己的工作内存(CPU缓存/寄存器)
3. 线程不能直接读写主内存,必须通过工作内存
4. 线程间变量的传递必须经过主内存
三大特性:
- 原子性:synchronized、Lock、AtomicXxx
- 可见性:volatile、synchronized、Lock
- 有序性:volatile、happens-before
| 序号 | 规则 | 含义 | 示例 |
|---|---|---|---|
| 1 | 程序顺序规则 | 同一线程中,前面的操作happens-before后面的操作 | 线程内代码按顺序执行 |
| 2 | 监视器锁规则 | unlock操作happens-before后续对同一锁的lock操作 | synchronized释放锁前的写入对下一个获取锁的线程可见 |
| 3 | volatile规则 | 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 | 多条规则组合推导 |
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 的原子性
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(布尔标记,轻量)
// 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;
}
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、性能监控),不需要精确值
/**
* 实验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: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();
}
}
}
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();
}
}
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;
}
}
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)");
}
}
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.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.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解决指令重排
编写程序,两个线程分别执行:
x = 1; flag = true;if(flag) { assert x == 1; }循环执行100万次,观察是否出现flag==true但x==0的情况。
只用Unsafe的compareAndSwapInt和getIntVolatile,手写一个支持get/set/incrementAndGet/compareAndSet的类。
阅读LongAdder源码,回答:
分别用以下方式实现"线程A执行完再执行线程B":
1. volatile + 自旋
2. synchronized + wait/notify
3. CountDownLatch
4. CompletableFuture
5. BlockingQueue
对比五种方式的优缺点和适用场景。