Java · JMM 内存模型与 volatile

场景 1 · 优雅停机的开关

Quartz/轮询任务收到 SIGTERM 后停止拉新任务, 跑完手头的再退出 — 单写多读的教科书场景:

public class Worker {
    private volatile boolean running = true;      // 立即可见于所有线程

    public void run() {
        while (running) {                    // 无 volatile: JIT 可能把 running 缓存进寄存器 → 死循环
            processOneJob();
        }
        drainAndFlush();
    }
    public void shutdown() { running = false; }  // shutdown hook / 信号处理器调用
}

场景 2 · 双重检查锁单例 (volatile 是正确性必需)

public class Router {
    private static volatile Router instance;   // 少了 volatile = 半成品风险

    public static Router get() {
        if (instance == null) {                 // 一读: 无锁快路径
            synchronized (Router.class) {
                if (instance == null)             // 二读: 防重复创建
                    instance = new Router();     // 分配→初始化→赋值可能重排!
            }
        }
        return instance;
    }
}
// 无 volatile: 线程B 可能看到非空但未初始化完的 instance → NPE 玄学

场景 3 · 配置热更新: volatile 引用 + 不可变对象

public final class Config {                 // 不可变: 所有字段 final
    private final Map<String, Integer> limits;
    private Config(Map<String, Integer> l) { this.limits = Map.copyOf(l); }
}
private volatile Config cfg = load();
void reload() { cfg = new Config(parseFromApollo()); }   // 整体替换, 读侧永远拿到一致一代
// 套路与 Go atomic.Pointer 快照相同: 写时整体换, 读时无锁拿快照

场景 4 · LongAdder 高并发监控埋点

千万级 QPS 的计数, AtomicLong 自旋浪费, LongAdder 分散热点:

public final class QpsCounter {
    private final LongAdder count = new LongAdder();
    public void hit() { count.increment(); }          // 写路径: 分散到 Cell, 几乎无竞争
    public long snapshot() { return count.sum(); }  // 读路径: 弱一致求和, 监控够用
}
# 读多写少要精确一致时仍是 AtomicLong; 监控计数一律 LongAdder

场景 5 · AtomicReferenceFieldUpdater 轻量热更

只有一两个字段需要原子更新时, 不必把整对象包 AtomicReference:

private static final AtomicReferenceFieldUpdater<Router, Rules> RULES =
    AtomicReferenceFieldUpdater.newUpdater(Router.class, Rules.class, "rules");
private volatile Rules rules;                        // 字段本身必须 volatile

public void reload(Rules next) { RULES.set(this, next); }   // 整体换快照
public Route match(String path) { return rules.find(path); }  // 无锁读

场景 6 · BlockingQueue 的 HB 语义当交接协议

put/take 自带 happens-before — 生产者放入前的所有写, 对拿到它的消费者可见, 常被忽略的白送保证:

BlockingQueue<Task> queue = new LinkedBlockingQueue<>(1000);
# 生产者: 构建完整个对象图(含内部 list/dict)才 put → 消费者 take 后完整可见
queue.put(newTask(ids, context));
# 消费者无需再加锁/volatile: take() 返回即已建立 HB 边
Task t = queue.take(); t.execute();

场景 7 · 优雅停机: 双阶段等待

volatile 停止位 + CountDownLatch 等清理完成, 两阶段各司其职:

private volatile boolean running = true;
private final CountDownLatch done = new CountDownLatch(4);

public void worker() {
    try { while (running) process(); }
    finally { flush(); done.countDown(); }        // 退出前必收尾
}
public void shutdown() throws InterruptedException {
    running = false;                                // 阶段1: 广播停
    if (!done.await(15, TimeUnit.SECONDS))       // 阶段2: 等收尾, 超时强杀
        log.warn("graceful timeout, some workers may not flush");
}

场景 8 · ConcurrentHashMap 复合原子操作

"没有就创建"的检查-放入必须用原子方法, 手写 containsKey+put 必丢:

ConcurrentHashMap<String, List<Metric>> groups = new ConcurrentHashMap<>();

# 好: 原子复合 — 同 key 并发只有一个 lambda 生效
groups.computeIfAbsent(key, k -> new CopyOnWriteArrayList<>()).add(m);

# merge 累加同款: counts.merge(id, 1L, Long::sum)

场景 9 · jcstress 复现可见性 bug

"偶尔重现"的并发问题, 用 OpenJDK 的并发压测框架变成确定性结论:

@JCStressTest
@Outcome(id = "1, 1", expect = ACCEPTABLE, desc = "串行或正确同步")
@Outcome(             expect = FORBIDDEN,  desc = "可见性丢失")
public static class VisibilityRace {
    int x; // 非 volatile: 压测能打出 FORBIDDEN 结果即实锤
    @Actor void writer(I r) { x = 1; r.r1 = 1; }
    @Actor void reader(I r) { r.r2 = x; }
}

场景 10 · 不可变对象 + 安全发布

final 字段的构造保证 + volatile 引用 = 无锁共享的黄金组合:

public final class RateTable {                    // final 类 + 全 final 字段
    private final double[] rates;
    RateTable(double[] src) { this.rates = src.clone(); }   // 防御性拷贝
    public double get(int i) { return rates[i]; }        // 只读, 天生线程安全
}
private volatile RateTable table = load();       // volatile 引用整体替换
# 读侧零锁零拷贝, 写侧原子换表 — 配置/汇率/路由的万能形态