《Java 并发编程·性能诊断与事故》2.3 从微基准到系统压测

static final AtomicInteger STOCK = new AtomicInteger(10_000_000);
static final ReentrantLock LOCK = new ReentrantLock();

static void downstream() {
    try {
        Thread.sleep(1);          // 模拟一次下游 RPC，1 ms
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

// A：锁包住扣减与三个下游调用
static void inlineReserve() {
    LOCK.lock();
    try {
        STOCK.decrementAndGet();
        for (int i = 0; i < 3; i++) {
            downstream();
        }
    } finally {
        LOCK.unlock();
    }
}

// B：锁只包住扣减
static void splitReserve() {
    LOCK.lock();
    try {
        STOCK.decrementAndGet();
    } finally {
        LOCK.unlock();
    }
    for (int i = 0; i < 3; i++) {
        downstream();
    }
}

static final int THREADS = 8;
static final long DURATION_NANOS = 10_000_000_000L;

static Result run(Op op) throws InterruptedException {
    long[][] perThread = new long[THREADS][];
    CountDownLatch ready = new CountDownLatch(THREADS);
    CountDownLatch go = new CountDownLatch(1);
    CountDownLatch done = new CountDownLatch(THREADS);

    for (int t = 0; t < THREADS; t++) {
        final int id = t;
        Thread.ofPlatform().name("client-" + t).start(() -> {
            long[] samples = new long[1 << 18];
            int n = 0;
            ready.countDown();
            try {
                go.await();
                long deadline = System.nanoTime() + DURATION_NANOS;
                while (System.nanoTime() < deadline) {
                    long start = System.nanoTime();
                    op.run();
                    if (n < samples.length) {
                        samples[n++] = System.nanoTime() - start;
                    }
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            perThread[id] = Arrays.copyOf(samples, n);
            done.countDown();
        });
    }

    ready.await();
    long start = System.nanoTime();
    go.countDown();                       // 所有线程对齐起跑线
    done.await();
    long elapsed = System.nanoTime() - start;

    long[] merged = merge(perThread);
    Arrays.sort(merged);
    return new Result(merged.length, elapsed, merged);
}

static long[] merge(long[][] perThread) {
    int total = 0;
    for (long[] s : perThread) {
        total += s.length;
    }
    long[] merged = new long[total];
    int off = 0;
    for (long[] s : perThread) {
        System.arraycopy(s, 0, merged, off, s.length);
        off += s.length;
    }
    return merged;
}

static double pct(long[] sorted, double p) {
    if (sorted.length == 0) {
        return -1;
    }
    int idx = (int) Math.min(sorted.length - 1L, Math.round(p * (sorted.length - 1)));
    return sorted[idx] / 1e6;          // ns -> ms
}

--- A: 锁包住三个下游调用 ---
n=2033 rps=202 p50=4.57ms p99=1242.67ms p999=4322.62ms max=4961.66ms
--- B: 锁只包住库存扣减 ---
n=17044 rps=1703 p50=4.52ms p99=11.75ms p999=17.91ms max=25.26ms

--- 第二次运行 ---
--- A ---
n=2142 rps=213 p50=4.55ms p99=20.62ms p999=6843.45ms max=7200.93ms
--- B ---
n=16496 rps=1645 p50=4.53ms p99=12.91ms p999=24.06ms max=35.35ms

ReserveCounterBench.atomicDecrement  thrpt  3  28485746.478 ± 124079265.612  ops/s
ReserveCounterBench.atomicDecrement:gc.alloc.rate.norm  thrpt  3  ≈ 10⁻⁴  B/op
ReserveCounterBench.atomicDecrement:gc.count            thrpt  3  ≈ 0     counts

package com.plume.conc.ops;

/** 压测结论：通过与否必须由阈值决定，不能由「看起来还行」决定。 */
public record LoadReport(
        String scenario,
        long requests,
        double rps,
        double p50Millis,
        double p99Millis,
        double p999Millis,
        double loadAverage,
        boolean pass,
        String note) {

    public static final double MAX_P99_MILLIS = 100.0;
    public static final double MIN_RPS = 500.0;

    public static LoadReport judge(String scenario, long requests, long elapsedNanos,
                                   long[] sortedNanos, double loadAverage) {
        double rps = requests / (elapsedNanos / 1_000_000_000.0);
        double p50 = pct(sortedNanos, 0.50) / 1e6;
        double p99 = pct(sortedNanos, 0.99) / 1e6;
        double p999 = pct(sortedNanos, 0.999) / 1e6;

        boolean pass = rps >= MIN_RPS && p99 <= MAX_P99_MILLIS;
        String note = pass ? "通过" : (rps < MIN_RPS ? "吞吐不足" : "尾延迟超标");
        return new LoadReport(scenario, requests, rps, p50, p99, p999, loadAverage, pass, note);
    }

    private static long pct(long[] sorted, double p) {
        int idx = (int) Math.min(sorted.length - 1L, Math.round(p * (sorted.length - 1)));
        return sorted[idx];
    }
}