多出来的响应时间，大多是在排队

package demo;

import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.jdbc.core.ConnectionCallback;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.*;

@SpringBootApplication
@RestController
public class DemoApp {
    private final JdbcTemplate jdbc;
    private final Timer sql;                       // 只量“拿到连接以后”SQL 自己花的时间

    DemoApp(JdbcTemplate jdbc, MeterRegistry registry) {
        this.jdbc = jdbc;
        this.sql = registry.timer("demo.sql");
    }

    public static void main(String[] args) { SpringApplication.run(DemoApp.class, args); }

    /** 实验 1、2：每个请求占一个数据库连接 20 ms，模拟一条 20 ms 的 SQL */
    @GetMapping("/work")
    public String work() {
        jdbc.execute((ConnectionCallback<Object>) con -> {      // 进到这里时，已经从连接池拿到连接了
            long t0 = System.nanoTime();
            con.createStatement().execute("CALL SLEEP_MS(20)");
            sql.record(System.nanoTime() - t0, java.util.concurrent.TimeUnit.NANOSECONDS);
            return null;
        });
        return "ok";
    }

    /** 实验 3：下单 = 插一行，再数一数这个用户有几单（user_id 上没有索引） */
    @PostMapping("/order")
    public Long order(@RequestParam long uid) {
        jdbc.update("INSERT INTO orders(user_id, amount) VALUES (?, 1)", uid);
        long t0 = System.nanoTime();
        Long n = jdbc.queryForObject("SELECT COUNT(*) FROM orders WHERE user_id = ?", Long.class, uid);
        sql.record(System.nanoTime() - t0, java.util.concurrent.TimeUnit.NANOSECONDS);
        return n;
    }

    /** 实验 3 收尾：给 user_id 补上索引（演示用，真实项目在数据库客户端里执行） */
    @PostMapping("/admin/add-index")
    public String addIndex() {
        jdbc.execute("CREATE INDEX IF NOT EXISTS idx_orders_user ON orders(user_id)");
        return "index added";
    }

    /** 选做：和 /work 一样占连接 20 ms，但每次往一个“只放不删”的本地缓存里塞 8 KB */
    static final java.util.Map<Long, byte[]> CACHE = new java.util.concurrent.ConcurrentHashMap<>();
    static final java.util.concurrent.atomic.AtomicLong SEQ = new java.util.concurrent.atomic.AtomicLong();
    @GetMapping("/leaky")
    public String leaky() {
        CACHE.put(SEQ.incrementAndGet(), new byte[8 * 1024]);
        return work();
    }

    /** 给 H2 用的自定义函数：SLEEP_MS(20) 就是“这条 SQL 要跑 20 ms” */
    public static void sleepMs(int ms) throws InterruptedException { Thread.sleep(ms); }
}

import java.net.URI;
import java.net.http.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;

/**
 * 最小压测机。两种发法：
 *   java Load.java closed 50  30 http://localhost:8090/work      50 个用户，各自“等回来再发下一个”
 *   java Load.java open   600 30 http://localhost:8090/work      每秒 600 个，到点就发，不管上一个回没回来
 * 每秒打一行：这一秒完成了几个、它们的 P50 / P99、此刻还有几个没回来。
 */
public class Load {
    static final ConcurrentLinkedQueue<Long> done = new ConcurrentLinkedQueue<>();
    static final AtomicInteger inflight = new AtomicInteger(), errors = new AtomicInteger();

    public static void main(String[] a) throws Exception {
        String mode = a[0];
        int n = Integer.parseInt(a[1]), secs = Integer.parseInt(a[2]);
        URI uri = URI.create(a[3]);
        boolean post = a.length > 4 && a[4].equals("POST");
        HttpClient http = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build();
        long start = System.nanoTime(), end = start + secs * 1_000_000_000L;

        if (mode.equals("closed")) {
            for (int i = 0; i < n; i++)
                Thread.ofVirtual().start(() -> {
                    while (System.nanoTime() < end) call(http, uri, post, System.nanoTime());
                });
        } else {
            Thread.ofPlatform().start(() -> {
                for (long k = 0; ; k++) {
                    long due = start + k * 1_000_000_000L / n;          // 第 k 个请求“应该”在这一刻发出
                    if (due > end) break;
                    while (System.nanoTime() < due) Thread.onSpinWait();
                    Thread.ofVirtual().start(() -> call(http, uri, post, due)); // 从计划时刻开始计时
                }
            });
        }
        System.out.println("  秒   完成/s   P50(ms)   P99(ms)   在途   错误");
        for (int s = 1; s <= secs; s++) {
            Thread.sleep(Math.max(0, (start + s * 1_000_000_000L - System.nanoTime()) / 1_000_000));
            List<Long> l = new ArrayList<>();
            for (Long x; (x = done.poll()) != null; ) l.add(x);
            Collections.sort(l);
            System.out.printf("%4d %8d %9d %9d %6d %6d%n", s, l.size(), pct(l, 50), pct(l, 99), inflight.get(), errors.getAndSet(0));
        }
        System.exit(0);
    }

    static void call(HttpClient http, URI uri, boolean post, long t0) {
        inflight.incrementAndGet();
        try {
            URI u = post ? URI.create(uri + "?uid=" + ThreadLocalRandom.current().nextInt(1000)) : uri;
            HttpRequest.Builder b = HttpRequest.newBuilder(u);
            HttpResponse<String> r = http.send(post ? b.POST(HttpRequest.BodyPublishers.noBody()).build() : b.build(),
                                               HttpResponse.BodyHandlers.ofString());
            if (r.statusCode() != 200) errors.incrementAndGet();
        } catch (Exception e) {
            errors.incrementAndGet();
        } finally {
            inflight.decrementAndGet();
            done.add((System.nanoTime() - t0) / 1_000_000);
        }
    }

    static long pct(List<Long> l, int p) {
        return l.isEmpty() ? 0 : l.get(Math.min(l.size() - 1, (int) Math.ceil(l.size() * p / 100.0) - 1));
    }
}

mvn -q package -DskipTests
java -jar target/rtdemo-1.0.jar              # 业务在 8090，Actuator 在 8091
javac -d classes Load.java                   # 压测机，另开一个终端
java -cp classes Load closed 20 5 http://localhost:8090/work   # 先预热 5 秒