《Java 并发编程·性能诊断与事故》1.2 上下文切换、调度延迟与 CPU 配额

症状：32 核机器上把池从 16 扩到 64，吞吐只涨 12%，us 从 60% 掉到 45%，
      sy 从 8% 涨到 25%，p99 从 30 ms 涨到 120 ms。
证据：vmstat 1 的 cs 列从 8 000/s 涨到 60 000/s；pidstat -w 显示 nvcswch/s
      占九成；线程池 activeCount 长期等于 poolSize。
根因：线程数远超可用核数，时间片变短，线程在锁等待中被换出，
      醒来时锁已被别人拿走，重试又被换出——切换本身不贵，贵的是它打乱了锁的交接。
修复：池大小按核数收敛，队列前置削峰，把阻塞调用从计算线程里挪走。
验证：同一压测，cs 回落到 10 000/s 以下，sy 回到 10% 以内，p99 回到 40 ms。

# 系统级：每秒一行，看整体是不是在疯狂轮转
vmstat 1 5

# 进程级：只盯住这个 JVM
pidstat -w -p <pid> 1 5
pidstat -u -p <pid> 1 5

$ which vmstat pidstat
vmstat not found
pidstat not found

$ uptime
2:19  up 9 days, 19:42, 6 users, load averages: 80.04 105.29 132.56

$ top -l 1 -n 0 | head -6
Processes: 717 total, 17 running, 700 sleeping, 6638 threads 
2026/10/29 02:19:20
Load Avg: 80.04, 105.29, 132.56 
CPU usage: 27.79% user, 28.12% sys, 44.7% idle 
SharedLibs: 578M resident, 132M data, 99M linkedit.
MemRegions: 1353020 total, 11G resident, 297M private, 3622M shared.

$ ps -M -p <pid> | wc -l                  # 85 行，含表头 → 84 条线程
$ jcmd <pid> Thread.print | grep -c '^"'  # 18
$ # 进程内部：Thread.getAllStackTraces().size() → 70

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.LongAdder;

public final class ThreadSweep {
    static final Object LOCK = new Object();
    static final int IND_ITERS = 20_000_000;
    static final int SHARED_ITERS = 3_000_000;
    static long shared;
    static final LongAdder SINK = new LongAdder();
    static final ThreadMXBean MX = ManagementFactory.getThreadMXBean();

    public static void main(String[] args) throws Exception {
        int[] levels = {1, 2, 4, 8, 16, 32, 64};
        System.out.println("mode        threads   run1    run2    run3   cpu_ns/op");
        for (boolean contended : new boolean[]{false, true}) {
            for (int n : levels) {
                double[] thr = new double[3];
                double cpu = 0;
                phase(n, contended);
                for (int r = 0; r < 3; r++) {
                    long t0 = System.nanoTime();
                    long cpuNs = phase(n, contended);
                    int ops = n * (contended ? SHARED_ITERS : IND_ITERS);
                    thr[r] = (double) ops / ((System.nanoTime() - t0) / 1e9) / 1e6;
                    cpu += (double) cpuNs / ops;
                }
                System.out.printf("%-11s %7d %7.1f %7.1f %7.1f %8.1f%n",
                        contended ? "shared" : "independent", n, thr[0], thr[1], thr[2], cpu / 3);
            }
        }
    }

    static long phase(int threads, boolean contended) throws Exception {
        CountDownLatch ready = new CountDownLatch(threads);
        CountDownLatch go = new CountDownLatch(1);
        LongAdder cpu = new LongAdder();
        Thread[] pool = new Thread[threads];
        for (int i = 0; i < threads; i++) {
            final int seed = i + 1;
            pool[i] = Thread.ofPlatform().unstarted(() -> {
                ready.countDown();
                try { go.await(); } catch (InterruptedException e) { return; }
                long b = MX.getCurrentThreadCpuTime();
                if (contended) {
                    for (int k = 0; k < SHARED_ITERS; k++) synchronized (LOCK) { shared++; }
                } else {
                    long x = seed;
                    for (int k = 0; k < IND_ITERS; k++) {
                        x = x * 6364136223846793005L + 1442695040888963407L;
                        x ^= x >>> 33;
                    }
                    SINK.add(x);
                }
                cpu.add(MX.getCurrentThreadCpuTime() - b);
            });
            pool[i].start();
        }
        ready.await();
        go.countDown();
        for (Thread t : pool) t.join();
        return cpu.sum();
    }
}

mode        threads   run1    run2    run3   cpu_ns/op
independent       1   607.4   610.1   620.8      1.6
independent       2  1222.5  1234.9  1216.8      1.6
independent       4  2395.8  2357.3  2365.3      1.6
independent       8  4642.1  4526.5  4597.9      1.7
independent      16  4452.3  4967.2  4975.9      1.7
independent      32  5264.8  5143.3  5187.9      1.7
independent      64  5217.2  5231.6  5074.0      1.7
shared            1   441.4   236.3   424.8      2.2
shared            2    99.3   106.6    87.5     20.1
shared            4    20.4    24.8    18.5     97.9
shared            8    15.8    19.0    16.4    120.0
shared           16    17.4    19.7    18.1    111.4
shared           32    18.3    16.0    16.3    120.9
shared           64    16.9    16.7    16.6    121.4

package com.plume.conc.ops;

import java.util.Arrays;
import java.util.concurrent.locks.LockSupport;

/** 调度延迟采样器：请求固定时长的 park，记录实际间隔。 */
public final class SchedulerSampler {
    private final long[] gaps;
    private int size;

    public SchedulerSampler(int capacity) {
        this.gaps = new long[capacity];
    }

    public void sample(long parkNanos) {
        long t0 = System.nanoTime();
        LockSupport.parkNanos(parkNanos);
        long dt = System.nanoTime() - t0;
        if (size < gaps.length) {
            gaps[size++] = dt;
        }
    }

    public long percentile(double p) {
        if (size == 0) {
            return 0L;
        }
        long[] copy = Arrays.copyOf(gaps, size);
        Arrays.sort(copy);
        return copy[Math.min(copy.length - 1, (int) Math.ceil(p * copy.length) - 1)];
    }

    public long max() {
        long m = 0L;
        for (int i = 0; i < size; i++) {
            m = Math.max(m, gaps[i]);
        }
        return m;
    }

    /** 一行 CSV，供压测报告归档。 */
    public String csv(long cpuNanos, long ops) {
        long cpuPerOp = ops == 0 ? 0 : cpuNanos / ops;
        return String.format("sched,n=%d,p50_ms=%.2f,p99_ms=%.2f,max_ms=%.2f,cpu_ns_per_op=%d",
                size, percentile(0.50) / 1e6, percentile(0.99) / 1e6, max() / 1e6, cpuPerOp);
    }

    public static void main(String[] args) throws Exception {
        int threads = args.length > 0 ? Integer.parseInt(args[0]) : 1;
        SchedulerSampler[] each = new SchedulerSampler[threads];
        Thread[] pool = new Thread[threads];
        for (int i = 0; i < threads; i++) {
            SchedulerSampler s = new SchedulerSampler(2000);
            each[i] = s;
            pool[i] = Thread.ofPlatform().name("probe-" + i).start(() -> {
                for (int k = 0; k < 2000; k++) {
                    s.sample(1_000_000L);
                }
            });
        }
        for (Thread t : pool) {
            t.join();
        }
        long samples = 0, p50 = 0, p99 = 0, max = 0;
        for (SchedulerSampler s : each) {
            samples += s.size;
            p50 = Math.max(p50, s.percentile(0.50));
            p99 = Math.max(p99, s.percentile(0.99));
            max = Math.max(max, s.max());
        }
        System.out.printf("threads=%d samples=%d p50=%.2f p99=%.2f max=%.2f (ms)%n",
                threads, samples, p50 / 1e6, p99 / 1e6, max / 1e6);
    }
}

$ java -cp out com.plume.conc.ops.SchedulerSampler 1
threads=1 samples=2000 p50=1.51 p99=2.76 max=13.61 (ms)
$ java -cp out com.plume.conc.ops.SchedulerSampler 8
threads=8 samples=16000 p50=1.51 p99=4.66 max=23.66 (ms)

# quota 与 period，单位微秒；"200000 100000" 表示 2 个核
cat /sys/fs/cgroup/cpu.max

# 被限流的次数和总时长：nr_periods / nr_throttled / throttled_usec
cat /sys/fs/cgroup/cpu.stat

$ java -cp out QuotaProbe
availableProcessors=10

$ java -XX:ActiveProcessorCount=2 -cp out QuotaProbe
availableProcessors=2

$ java -XX:ActiveProcessorCount=4 -cp out QuotaProbe
availableProcessors=4