《Java 并发编程·性能诊断与事故》9.3 从事故到 happens-before 归因

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.HashMap;
import java.util.Map;

public class StuckLoopDetector {

    public static void main(String[] args) throws Exception {
        Thread worker = new Thread(() -> {
            while (!StopFlag.stop) { }      // 非 volatile 标志
        }, "worker-loop");
        worker.setDaemon(true);
        worker.start();
        Thread.sleep(1500);
        StopFlag.stop = true;               // 走到这里也停不下来
        new StuckLoopDetector().report(worker.threadId());
        System.exit(0);
    }

    static final class StopFlag {
        static boolean stop;
    }

    void report(long targetId) throws InterruptedException {
        ThreadMXBean mx = ManagementFactory.getThreadMXBean();
        Map<Long, Long> cpu0 = snapshotCpu(mx);
        ThreadInfo before = find(mx, targetId);
        long wall0 = System.nanoTime();
        Thread.sleep(500);
        long wall1 = System.nanoTime();
        ThreadInfo after = find(mx, targetId);
        Map<Long, Long> cpu1 = snapshotCpu(mx);
        if (before == null || after == null) {
            System.out.println("thread gone");
            return;
        }
        String f0 = topFrame(before);
        String f1 = topFrame(after);
        long cpuDeltaMs = (cpu1.getOrDefault(targetId, 0L)
                - cpu0.getOrDefault(targetId, 0L)) / 1_000_000;
        long wallDeltaMs = (wall1 - wall0) / 1_000_000;
        String verdict = (f0.equals(f1)
                && after.getThreadState() == Thread.State.RUNNABLE
                && cpuDeltaMs * 100 / Math.max(wallDeltaMs, 1) >= 80)
                ? "SPINNING" : "NOT_SPINNING";
        System.out.printf("thread=%s state=%s%n", after.getThreadName(), after.getThreadState());
        System.out.printf("frame_1=%s%nframe_2=%s%n", f0, f1);
        System.out.printf("cpuDeltaMs=%d wallDeltaMs=%d%n", cpuDeltaMs, wallDeltaMs);
        System.out.println("verdict=" + verdict);
    }

    Map<Long, Long> snapshotCpu(ThreadMXBean mx) {
        Map<Long, Long> m = new HashMap<>();
        for (long id : mx.getAllThreadIds()) {
            long t = mx.getThreadCpuTime(id);
            if (t >= 0) {
                m.put(id, t);
            }
        }
        return m;
    }

    ThreadInfo find(ThreadMXBean mx, long id) {
        ThreadInfo[] infos = mx.getThreadInfo(new long[]{id}, Integer.MAX_VALUE);
        return infos.length > 0 ? infos[0] : null;
    }

    String topFrame(ThreadInfo info) {
        StackTraceElement[] st = info.getStackTrace();
        return st.length == 0 ? "<none>" : st[0].toString();
    }
}

thread=worker-loop state=RUNNABLE
frame_1=app//StuckLoopDetector.lambda$main$0(StuckLoopDetector.java:11)
frame_2=app//StuckLoopDetector.lambda$main$0(StuckLoopDetector.java:11)
cpuDeltaMs=507 wallDeltaMs=510
verdict=SPINNING

事故编号：
发现时间 / 影响面：
现象（可观测事实，含次数与时间）：
时间线：
  T0 触发动作：
  T1 异常表现：
  T2 处置动作：
现场证据（转储 / JFR / 日志 / 指标）：
复现实验（代码、命令、样本数、命中率）：
候选假设与排除过程：
  H1 ... 排除依据 ...
  H2 ... 保留 ...
违规的 happens-before 规则：
根因（一句话，能对应到规则或源码）：
修复（补了哪条边，为什么足够）：
验证（修复前后同一实验的对比数据）：
回归（测试名、CI 挂载点、失败判据）：
遗留风险：

事故编号：CONC-2026-091
现象：停机标志置位后进程不退出，线程 100% CPU，30/30 次独立运行复现
现场证据：两次 jcmd Thread.print 同帧同状态；JFR 458 个 ExecutionSample 同帧
复现实验：独立 JVM 30 次 30 次卡死；-Xint 0/10；C1-only 0/10；C2-only 10/10
违规规则：普通字段写读之间无 HB，C2 允许把读提升出循环
根因：while (!stop) 中 stop 非 volatile，OSR 后循环条件成为常量
修复：stop 改 volatile，写读构成 release/acquire
验证：同命令 30 次全部退出；JFR 中不再出现该帧持续采样
回归：VisibilityRegression#sweeperStopsWithinTimeout，超时 2s 判失败
遗留风险：其它轮询标志需全量排查

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

public final class VisibilityRegression {

    static int failures;

    public static void main(String[] args) throws Exception {
        sweeperStopsWithinTimeout();
        publicationHasNoTornState();
        System.out.println(failures == 0 ? "PASS" : "FAIL " + failures);
        System.exit(failures == 0 ? 0 : 1);
    }

    static void sweeperStopsWithinTimeout() throws Exception {
        final class Sweeper implements Runnable {
            volatile boolean running = true;

            @Override
            public void run() {
                while (running) {
                    Thread.onSpinWait();
                }
            }

            void shutdown() {
                running = false;
            }
        }
        Sweeper sweeper = new Sweeper();
        Thread t = new Thread(sweeper, "sweeper");
        t.start();
        Thread.sleep(200);
        sweeper.shutdown();
        t.join(2000);
        if (t.isAlive()) {
            failures++;
            System.out.println("FAIL sweeper did not stop");
            t.interrupt();
        }
    }

    static void publicationHasNoTornState() throws Exception {
        final class Config {
            final int timeoutMs;

            Config(int timeoutMs) {
                this.timeoutMs = timeoutMs;
            }
        }
        AtomicReference<Config> current = new AtomicReference<>();
        AtomicInteger bad = new AtomicInteger();
        AtomicInteger reads = new AtomicInteger();

        Thread reader = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                Config c = current.get();
                if (c != null && c.timeoutMs != 42) {
                    bad.incrementAndGet();
                }
                reads.incrementAndGet();
            }
        }, "reader");
        reader.setDaemon(true);
        reader.start();
        for (int i = 0; i < 1_000_000; i++) {
            current.set(new Config(42));
        }
        Thread.sleep(50);
        reader.interrupt();
        reader.join();
        if (bad.get() != 0) {
            failures++;
            System.out.println("FAIL bad reads = " + bad.get());
        }
        System.out.println("publishRounds=1000000 reads=" + reads.get()
                + " bad=" + bad.get());
    }
}

publishRounds=1000000 reads=9351290 bad=0
PASS

reads=7497925 bad=0
reads=7368947 bad=0
reads=7547791 bad=0