Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

Git, DevOps & ToolingSenior22 phút đọc

Performance test: load, stress, spike, soak và coordinated omission

Ôn 14 thẻ
Trong bài này

Một bài load test sai cho ra con số đẹp và một sự cố thật vài tuần sau. Bài này đi từ mục tiêu (SLO) tới mô hình tải, cách đo latency cho đúng, công cụ, và cách đọc kết quả để tìm bottleneck. Phần coordinated omission có thí nghiệm nhỏ chạy bằng JDK 21, số đo là số thật trên máy mình.

1. Năm loại test, mỗi loại trả lời một câu hỏi

Ý chính: loại test được chọn theo câu hỏi cần trả lời, không theo công cụ. Cùng một script, chỉ khác hình dạng tải theo thời gian.

Loại Câu hỏi Hình dạng tải Bắt được gì
Smoke Script và hệ thống có chạy không? Rất nhỏ, 1–2 phút Script sai, môi trường hỏng
Load Tải dự kiến có đạt SLO không? Tăng dần tới peak, giữ 15–60 phút Hồi quy hiệu năng, cấu hình sai
Stress Vượt tải thì hỏng thế nào, có hồi lại không? Tăng quá peak tới khi lỗi Cách hệ thống gãy, timeout, retry storm
Spike Tải nhảy vọt trong vài giây thì sao? Từ thấp lên gấp 5–10 lần ngay Autoscale chậm, pool lạnh, hàng đợi đầy
Soak (endurance) Chạy lâu có xuống cấp không? Khoảng 70–80% peak, 4–24 giờ Rò bộ nhớ, connection leak, log đầy đĩa
Capacity (breakpoint) Tối đa bao nhiêu mà vẫn đạt SLO? Tăng từng bậc, mỗi bậc giữ vài phút Điểm gãy, tài nguyên cạn trước tiên

Stress test còn trả lời gãy có êm không: trả 503 nhanh rồi hồi lại là tốt, treo mọi request rồi chết hẳn là xấu (xem timeout và circuit breaker).

2. Mục tiêu bắt đầu từ SLO

Ý chính: mục tiêu là một câu có số và điều kiện, lấy từ SLO và lưu lượng thật: tốc độ đến, phân bố request, latency theo percentile, tỉ lệ lỗi. Không có số thì không có pass hay fail.

  • Tốc độ: peak thật từ metric production (không phải trung bình ngày) nhân hệ số dự phòng: 300 req/s × 1,5 = 450 req/s. Thiếu dữ liệu thì ước lượng.
  • Hỗn hợp request: ví dụ 70% danh sách, 20% chi tiết, 10% đặt hàng. Test một endpoint là đo một hệ thống khác.
  • Ngưỡng: p95, p99 theo nhóm endpoint, tỉ lệ lỗi, và ngưỡng tài nguyên (CPU < 70% ở peak để còn chỗ cho failover).

Ghi ngưỡng vào script để công cụ tự fail trong pipeline. “Chịu tải tốt” không phải mục tiêu; “p99 < 300 ms ở 450 req/s trong 30 phút, lỗi < 0,1%” mới là mục tiêu.

3. Mô hình tải: open và closed

Ý chính: closed model có N user ảo, mỗi user gửi, chờ response, nghỉ (think time) rồi gửi tiếp, nên server chậm thì tải tự giảm. Open model gửi theo tốc độ đến cố định bất kể response, giống người dùng Internet thật. Hầu hết API công khai nên test bằng open model.

flowchart LR
    subgraph Closed["Closed: N user cố định"]
        U[User ảo] -->|gửi| S1[Server]
        S1 -->|response| U
        U -->|nghỉ think time| U
    end
    subgraph Open["Open: tốc độ đến cố định"]
        A[Lịch đến: 500 req/s] -->|gửi đúng giờ| S2[Server]
        S2 -->|response về khi nào thì về| X[Ghi latency]
    end

Với closed model, throughput = N / (thời gian phản hồi + think time). 100 user, think time 1 s, response 0,1 s cho khoảng 91 req/s; server chậm thành 2 s thì chỉ còn 33 req/s. Tải giảm đúng lúc lẽ ra phải dồn lên.

4. Coordinated omission: đo sai một cách có hệ thống

Ý chính: công cụ chờ response mới gửi request tiếp theo sẽ không gửi trong lúc server đứng hình, nên bỏ sót đúng những request lẽ ra phải chờ lâu nhất. Cách sửa: tính latency từ thời điểm lẽ ra phải gửi, hoặc dùng open model.

Tên do Gil Tene đặt: công cụ “phối hợp” với server để bỏ qua mẫu xấu. Thí nghiệm: server HttpServer của JDK, mỗi request khoảng 1 ms, cứ 5 giây đứng hình 1 giây (giả lập GC pause hay lock dài). Bộ tạo tải gửi 200 req/s trong 20 giây (4.000 request) sau 3 giây warm-up.

Cách đo (ms) avg p50 p90 p99 p99.9 max
Closed, tính từ lúc gửi thật 2,76 1,72 2,11 2,63 1.002 1.007
Closed, tính từ lúc lẽ ra gửi 147,6 2,51 666,9 974,7 1.003 1.007
Open (virtual thread), tính từ lúc lẽ ra gửi 106,8 2,73 521,7 956,9 1.003 1.011

Máy: Apple M4 10 nhân, macOS 27.2, JDK 21.0.13, client và server cùng máy; ba lần chạy (lần cuối với đúng mã trong bài) lệch nhau dưới 3%. Cách đo đầu chỉ ghi vài mẫu chậm (mỗi lần stall một mẫu, khoảng 0,1% số mẫu), nên p99 trông hoàn hảo dù cứ 5 giây người dùng chờ tới 1 giây. Open model cho p90 ≈ 0,52 s, khớp lý thuyết: khoảng 20% thời gian server đứng hình, request đến trong lúc đó chờ đều từ 0 tới 1 s.

Trung bình 148 ms cũng vô nghĩa: không request nào như vậy, đa số 2–3 ms, số còn lại hàng trăm ms.

Mã nguồn thí nghiệm và lệnh chạy
// StallServer.java: mỗi request ~1 ms, cứ 5 s lại đứng hình 1 s
import com.sun.net.httpserver.HttpServer;
import java.net.InetSocketAddress;
import java.util.concurrent.Executors;

public class StallServer {
    static final Object LOCK = new Object();
    public static void main(String[] args) throws Exception {
        HttpServer s = HttpServer.create(new InetSocketAddress(8080), 1024);
        s.createContext("/", ex -> {
            synchronized (LOCK) { }               // bị chặn khi đang stall
            try { Thread.sleep(1); } catch (InterruptedException e) { }
            byte[] body = "ok".getBytes();
            ex.sendResponseHeaders(200, body.length);
            ex.getResponseBody().write(body);
            ex.close();
        });
        s.setExecutor(Executors.newFixedThreadPool(8));
        s.start();
        Thread.ofPlatform().daemon().start(() -> {
            while (true) {
                try { Thread.sleep(5000); synchronized (LOCK) { Thread.sleep(1000); } }
                catch (InterruptedException e) { return; }
            }
        });
    }
}
// LoadGen.java: java LoadGen closed|open <rps> <seconds>
import java.net.URI;
import java.net.http.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.LockSupport;

public class LoadGen {
    public static void main(String[] a) throws Exception {
        String mode = a[0]; int rps = Integer.parseInt(a[1]); int secs = Integer.parseInt(a[2]);
        HttpClient c = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build();
        HttpRequest req = HttpRequest.newBuilder(URI.create("http://localhost:8080/")).build();
        long interval = 1_000_000_000L / rps;
        long wEnd = System.nanoTime() + 3_000_000_000L;            // warm-up 3 s
        while (System.nanoTime() < wEnd) c.send(req, HttpResponse.BodyHandlers.discarding());
        long total = (long) rps * secs, start = System.nanoTime();
        if (mode.equals("closed")) {
            List<Long> naive = new ArrayList<>(), corrected = new ArrayList<>();
            for (long i = 0; i < total; i++) {
                long intended = start + i * interval;
                long now;
                while ((now = System.nanoTime()) < intended) LockSupport.parkNanos(intended - now);
                long sent = System.nanoTime();
                c.send(req, HttpResponse.BodyHandlers.discarding()); // chờ response: closed
                long done = System.nanoTime();
                naive.add(done - sent);          // bị coordinated omission
                corrected.add(done - intended);  // tính cả thời gian lẽ ra đã phải gửi
            }
            report("closed, from actual send", naive);
            report("closed, from intended send", corrected);
        } else {
            Queue<Long> lat = new ConcurrentLinkedQueue<>();
            CountDownLatch done = new CountDownLatch((int) total);
            for (long i = 0; i < total; i++) {
                long intended = start + i * interval;
                long now;
                while ((now = System.nanoTime()) < intended) LockSupport.parkNanos(intended - now);
                Thread.startVirtualThread(() -> {                  // không chờ: open
                    try { c.send(req, HttpResponse.BodyHandlers.discarding()); } catch (Exception e) { }
                    lat.add(System.nanoTime() - intended); done.countDown();
                });
            }
            done.await();
            report("open, from intended send", new ArrayList<>(lat));
        }
    }
    static void report(String name, List<Long> ns) {
        long[] v = ns.stream().mapToLong(Long::longValue).sorted().toArray();
        System.out.printf("%-28s n=%d avg=%.2f p50=%.2f p90=%.2f p99=%.2f p99.9=%.2f max=%.2f ms%n",
            name, v.length, Arrays.stream(v).average().orElse(0) / 1e6,
            p(v, 50), p(v, 90), p(v, 99), p(v, 99.9), v[v.length - 1] / 1e6);
    }
    static double p(long[] v, double q) { return v[(int) Math.ceil(q / 100 * v.length) - 1] / 1e6; }
}
$ javac -d out StallServer.java LoadGen.java && java -cp out StallServer &
$ java -cp out LoadGen closed 200 20
closed, from actual send     n=4000 avg=2.76 p50=1.72 p90=2.11 p99=2.63 p99.9=1002.16 max=1006.61 ms
closed, from intended send   n=4000 avg=147.62 p50=2.51 p90=666.90 p99=974.67 p99.9=1003.20 max=1007.32 ms
$ java -cp out LoadGen open 200 20
open, from intended send     n=4000 avg=106.82 p50=2.73 p90=521.70 p99=956.94 p99.9=1003.32 max=1010.65 ms

Closed có sửa cho p90 cao hơn open (667 so với 522 ms) vì sau mỗi lần stall, một thread phải gửi bù khoảng 200 request nối đuôi nhau, mỗi cái ~1,7 ms, nên phần bù cũng xếp hàng thêm. Open gửi bù song song, 8 thread server xử lý cùng lúc.

5. Đo gì: throughput, percentile, lỗi và saturation

Ý chính: bốn số cho mỗi bậc tải: throughput đạt được, p50/p95/p99, tỉ lệ lỗi, và mức bão hoà của tài nguyên. RED mô tả service từ phía người dùng, USE mô tả từng tài nguyên bên trong.

  • RED (mỗi endpoint): Rate (req/s), Errors (kể cả timeout phía client), Duration (phân bố latency).
  • USE (mỗi tài nguyên): Utilization (bận bao nhiêu %), Saturation (bao nhiêu việc đang chờ: run queue, request chờ connection, thread chờ lock), Errors.
  • Saturation báo sớm hơn utilization. Với hàng đợi đơn giản (M/M/1), thời gian phản hồi ≈ thời gian phục vụ / (1 − utilization): 80% bận là gấp 5 lần, 90% gấp 10 lần. Latency tăng vọt ở “khuỷu” trước khi CPU chạm 100%.
Định luật Little để kiểm tra chéo

6. Công cụ: k6, Gatling, JMeter

Ý chính: k6 (script JavaScript) gọn cho API và CI; Gatling (DSL Java/Kotlin/Scala) hợp team Java, báo cáo HTML tốt; JMeter (GUI, XML) nhiều giao thức nhưng mặc định closed model.

// k6: open model 450 req/s trong 30 phút, fail nếu trượt SLO
import http from 'k6/http';
import { check } from 'k6';

export const options = {
  scenarios: {
    peak: {
      executor: 'constant-arrival-rate',  // open model
      rate: 450, timeUnit: '1s', duration: '30m',
      preAllocatedVUs: 200, maxVUs: 1000, // thiếu VU thì iteration bị bỏ (dropped_iterations)
    },
  },
  thresholds: {
    http_req_failed: ['rate<0.001'],
    'http_req_duration{name:listProducts}': ['p(95)<150', 'p(99)<300'],
    dropped_iterations: ['count<1'],      // tải mục tiêu thật sự đã được tạo ra
  },
};

export default function () {
  const page = Math.floor(Math.random() * 50);
  const res = http.get(`${__ENV.BASE_URL}/products?page=${page}`, { tags: { name: 'listProducts' } });
  check(res, { 'status 200': (r) => r.status === 200 });
}
So sánh công cụ và phác thảo Gatling Java DSL
Công cụ Viết script Open model Điểm mạnh Điểm yếu
k6 JavaScript constant-arrival-rate, ramping-arrival-rate Gọn, threshold làm pass/fail, hợp CI Không chạy thư viện Java trong script
Gatling Java, Kotlin, Scala DSL injectOpen (và injectClosed) Cùng ngôn ngữ với team, báo cáo đẹp, hiệu quả tài nguyên Phải học DSL, build bằng Maven/Gradle
JMeter GUI, lưu XML Open Model Thread Group (từ 5.5) Nhiều giao thức (JDBC, JMS), cộng đồng lớn File XML khó review, tốn tài nguyên
import static io.gatling.javaapi.core.CoreDsl.*;
import static io.gatling.javaapi.http.HttpDsl.*;

import io.gatling.javaapi.core.*;
import io.gatling.javaapi.http.*;
import java.time.Duration;

public class ProductSimulation extends Simulation {

    HttpProtocolBuilder httpProtocol = http
        .baseUrl(System.getProperty("baseUrl", "http://localhost:8080"))
        .acceptHeader("application/json");

    FeederBuilder<String> users = csv("users.csv").random();   // dữ liệu thật, không lặp một id

    ScenarioBuilder browse = scenario("browse then view")
        .feed(users)
        .exec(http("listProducts").get("/products?page=#{page}").check(status().is(200)))
        .pause(Duration.ofSeconds(1), Duration.ofSeconds(3))     // think time trong phiên
        .exec(http("productDetail").get("/products/#{productId}").check(status().is(200)));

    {
        setUp(browse.injectOpen(                                 // open model: phiên đến theo tốc độ
                rampUsersPerSec(10).to(200).during(Duration.ofMinutes(2)),
                constantUsersPerSec(200).during(Duration.ofMinutes(30))))
            .protocols(httpProtocol)
            .assertions(
                global().responseTime().percentile(99.0).lt(300),
                global().failedRequests().percent().lt(0.1));
    }
}

injectOpen điều khiển tốc độ phiên đến; trong một phiên, các request vẫn nối đuôi nhau như người dùng thật. Script này chưa được chạy trong lúc viết bài (không dựng project Gatling), chỉ đối chiếu API với tài liệu Gatling.

7. Môi trường, dữ liệu và warm-up

Ý chính: kết quả chỉ đúng khi môi trường giống production về cấu hình, kích thước dữ liệu và kiểu truy cập. Dữ liệu nhỏ hay lặp lại nằm gọn trong cache và cho số đẹp giả.

  • Môi trường: cùng loại máy, CPU/memory limit, số pod và cấu hình pool như production (xem JVM trong container). Bên thứ ba (thanh toán, SMS) thay bằng stub có độ trễ giống thật.
  • Dữ liệu: database cỡ production, phân bố thật (vài khách hàng có rất nhiều đơn), id ngẫu nhiên từ feeder thay vì một id cố định.
  • Warm-up: JVM chạy chậm lúc đầu (thông dịch, rồi JIT C1, C2 biên dịch dần), cache và pool còn lạnh. Bỏ vài phút đầu khỏi kết quả, nhưng đo riêng cold start: đó là lúc pod mới nhận traffic khi deploy hay autoscale.

8. Tìm bottleneck

Ý chính: tăng tải từng bậc và tìm tài nguyên bão hoà đầu tiên: thứ có hàng đợi tăng khi throughput ngừng tăng. Mỗi triệu chứng có một công cụ để xác nhận.

Triệu chứng Nghi ngờ Xác nhận bằng Đọc thêm
CPU thấp, latency tăng, thread chờ getConnection Pool connection DB cạn Metric hikaricp.connections.pending, thời gian acquire Kích thước pool
Latency tăng dần trong soak, có lúc nhảy vọt GC, rò bộ nhớ GC log, JFR, heap sau mỗi full GC JVM trong container
Throughput đứng yên, thread pool đầy Thiếu thread, gọi blocking Thread dump (jcmd <pid> Thread.print) Thread pool và virtual thread
Nhiều thread BLOCKED cùng một monitor Lock trong ứng dụng Thread dump, JFR lock profiling Race condition và deadlock
DB CPU cao hoặc lock wait Câu SQL chậm, N+1, khoá dòng EXPLAIN ANALYZE, slow log, data_locks EXPLAIN ANALYZE, lock InnoDB
CPU usage trung bình thấp mà p99 cao Bị throttle bởi CPU limit nr_throttled trong cgroup CPU quota
Không biết request chậm ở service nào Một hop trong chuỗi gọi Trace của request chậm Distributed tracing

Sửa từng chỗ, đo lại sau mỗi thay đổi; bottleneck dời sang chỗ khác là tiến triển.

9. Báo cáo kết quả và JMH

Ý chính: báo cáo phải để người khác chạy lại và so được: môi trường, mô hình tải, số theo bậc, tài nguyên bão hoà đầu tiên, kết luận so với SLO. JMH trả lời câu hỏi khác: đoạn code nào nhanh hơn, trong một JVM.

Mẫu báo cáo kết quả
  1. Mục tiêu và ngưỡng (từ SLO), kết luận pass/fail trong một câu.
  2. Môi trường: phiên bản, cấu hình, số pod, kích thước dữ liệu, vị trí máy tạo tải.
  3. Mô hình tải: open hay closed, hỗn hợp request, thời gian warm-up và giữ tải.
  4. Bảng mỗi bậc: req/s đạt được, p50/p95/p99/max, tỉ lệ lỗi, CPU, pool, GC.
  5. Bottleneck, bằng chứng (biểu đồ, thread dump), đề xuất, và so với lần chạy trước.
Khung JMH và những lỗi hay gặp
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 5, time = 1)
@Fork(2)                                  // chạy trong JVM mới, tránh nhiễu giữa các benchmark
@State(Scope.Benchmark)
public class ParseBenchmark {
    String input = "2026-11-18T10:15:30Z";

    @Benchmark
    public Instant parse() {              // trả về kết quả để JIT không xoá code
        return Instant.parse(input);
    }

    @Benchmark
    public void parseIntoBlackhole(Blackhole bh) {
        bh.consume(Instant.parse(input));
    }
}

Lỗi hay gặp: tự đo bằng System.nanoTime() trong vòng lặp (dính warm-up, dead code elimination), input là hằng số nên JIT gấp lại (constant folding), chỉ chạy một fork. Đoạn này là khung tham khảo, chưa chạy trong lúc viết bài.

Bài tập

Bài 1: Closed model tự giảm tải

Công cụ chạy closed model: 50 user ảo, think time 1 s. Bình thường response mất 200 ms. Trong một sự cố, response tăng lên 2 s. Throughput mà công cụ tạo ra trước và trong sự cố là bao nhiêu? Production thật (open model, 40 req/s) sẽ thấy gì trong sự cố đó?

Lời giải Bài 1
  • Trước sự cố: throughput = N / (R + Z) = 50 / (0,2 + 1) ≈ 41,7 req/s.
  • Trong sự cố: 50 / (2 + 1) ≈ 16,7 req/s. Công cụ tự giảm tải 60% đúng lúc server yếu, nên server có thể “hồi” và báo cáo trông dễ chịu.
  • Production: người dùng vẫn đến 40 req/s. Nếu server chậm vì quá tải, nó không theo kịp 40 req/s, hàng đợi tăng liên tục, latency tăng tới khi timeout, và retry của client làm tải còn tăng thêm. Nếu server vẫn giữ được 2 s, định luật Little cho 40 × 2 = 80 request đang xử lý cùng lúc, nhiều hơn 50 mà công cụ tạo ra: test đã đo một tải nhẹ hơn thực tế.
  • Bài học: muốn biết hành vi khi quá tải, dùng open model với rate cố định, và theo dõi số request đang chờ.

Bài 2: Tự viết bộ tạo tải không bị coordinated omission

Viết một bộ tạo tải bằng Java 21 gửi đúng 200 req/s và ghi latency đúng ngay cả khi server đứng hình. Chạy với một server giả lập stall và so với cách đo ngây thơ.

Lời giải Bài 2

Lời giải chính là LoadGen ở phần 4. Ba ý quan trọng:

  1. Mỗi request có thời điểm dự kiến start + i × interval, tính trước, không phụ thuộc request trước đã xong chưa.
  2. Latency = thời điểm nhận response − thời điểm dự kiến (không phải thời điểm gửi thật).
  3. Để gửi đúng lịch khi server chậm, mỗi request chạy trên một virtual thread riêng; số request đang bay lúc stall ≈ 200 req/s × 1 s = 200 (định luật Little), virtual thread chịu được dễ dàng.

Kết quả đo đã có trong bảng phần 4: cách ngây thơ p99 = 2,63 ms, cách đúng p99 ≈ 957–975 ms. Bản production nên lưu latency vào HdrHistogram (có sẵn hàm recordValueWithExpectedInterval để sửa coordinated omission) thay vì danh sách Long.

Ghi nhớ

  • Nói được mỗi loại test (load, stress, spike, soak, capacity) trả lời câu hỏi gì.
  • Viết được mục tiêu bằng số từ SLO và biến nó thành threshold tự fail.
  • Giải thích được vì sao closed model che giấu quá tải.
  • Giải thích được coordinated omission bằng ví dụ có số, và cách sửa.
  • Từ một triệu chứng, chỉ ra tài nguyên nghi ngờ và công cụ xác nhận.

Câu hỏi phỏng vấn

Junior

Load test, stress test và soak test khác nhau thế nào?

Load test kiểm tra tải dự kiến có đạt SLO không, stress test đẩy quá tải để xem hệ thống gãy thế nào, soak test giữ tải vừa trong nhiều giờ để tìm lỗi tích luỹ.

Spike test thêm tình huống tải nhảy vọt trong vài giây, capacity test tìm mức tải tối đa còn đạt SLO. Cùng một script, chỉ khác hình dạng tải theo thời gian.

Vì sao báo cáo p99 thay vì latency trung bình?

Trung bình che mất đuôi chậm; p99 cho biết 1% request chậm nhất phải chờ bao lâu.

Trong thí nghiệm của bài, trung bình 148 ms không giống request nào: đa số 2–3 ms, phần còn lại hàng trăm ms. Một trang gọi nhiều API sẽ gặp đuôi chậm thường xuyên hơn nhiều so với 1%.

Mid

Open model và closed model khác nhau thế nào, chọn cái nào?

Closed model có số user cố định, chờ response mới gửi tiếp nên tải tự giảm khi server chậm; open model gửi theo tốc độ đến cố định bất kể response.

API công khai nên test bằng open model vì người dùng không biết server đang chậm. Closed model hợp với hệ thống có số client giới hạn như worker hay batch. Với closed model, throughput = N / (thời gian phản hồi + think time).

Coordinated omission là gì?

Là lỗi đo khi công cụ chờ response mới gửi tiếp: lúc server đứng hình, công cụ ngừng gửi nên chỉ ghi được một mẫu chậm thay vì hàng trăm.

Trong thí nghiệm, server đứng hình 1 s mỗi 5 s: đo ngây thơ p99 = 2,6 ms, đo từ thời điểm lẽ ra phải gửi p99 = 975 ms. Sửa bằng open model, tính latency từ thời điểm dự kiến, hoặc công cụ có sửa như wrk2, HdrHistogram.

Bạn đặt mục tiêu cho một đợt load test thế nào?

Từ SLO và lưu lượng production: tốc độ peak nhân hệ số dự phòng, hỗn hợp request thật, ngưỡng p95/p99 và tỉ lệ lỗi theo endpoint, cộng ngưỡng tài nguyên.

Ghi tất cả vào script dưới dạng threshold để test tự fail và chạy được trong CI. Không có số thì không có kết luận.

Senior

Throughput dừng ở 800 req/s trong khi CPU của service chỉ 40%. Bạn điều tra thế nào?

CPU thấp mà throughput đứng yên nghĩa là có thứ đang chờ: tìm tài nguyên có hàng đợi tăng.

  • Kiểm tra bộ tạo tải trước: CPU của nó, dropped_iterations.
  • Pool: request chờ connection DB (hikaricp.connections.pending), pool HTTP client, thread pool của server đầy.
  • Lock: thread dump nhiều thread BLOCKED cùng một monitor, lock wait trong DB.
  • Phía sau: DB, service phụ thuộc chậm (xem trace), CPU throttle do limit.
  • Định luật Little: 800 req/s × latency cho số request đang xử lý; so với kích thước các pool để thấy pool nào đầy.
Bạn có p99 của 10 pod. p99 của cả service là bao nhiêu?

Không tính được từ mười con số đó: percentile không trung bình hay cộng được. Phải gộp histogram rồi tính.

Dùng metric dạng histogram (bucket đếm), cộng bucket của mọi pod rồi tính histogram_quantile. Trung bình p99 thường thấp hơn p99 thật khi một pod chậm hơn hẳn các pod khác.

Khi nào dùng JMH, khi nào dùng load test?

JMH so hai cách cài đặt một đoạn code trong một JVM; load test kiểm tra cả hệ thống có đạt SLO dưới tải đồng thời.

JMH lo warm-up, fork và chống dead code elimination, nhưng không thấy DB, mạng, lock giữa request. Profile dưới tải trước để biết hàm nào đáng tối ưu, rồi mới dùng JMH; nếu không, cải thiện 30% một hàm chiếm 2% thời gian request chẳng đổi được p99.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu tiếng Anh dùng trong phỏng vấn
load test /loʊd test/ test với tải dự kiến “The load test runs at peak traffic times one and a half.”
soak test /soʊk test/ test chạy dài “The soak test found a connection leak after six hours.”
arrival rate /əˈraɪ.vəl reɪt/ tốc độ request đến “We model users with a fixed arrival rate, not a fixed number of threads.”
think time /θɪŋk taɪm/ thời gian nghỉ giữa hai thao tác “Each session has one to three seconds of think time.”
coordinated omission /koʊˈɔːr.dən.eɪ.tɪd oʊˈmɪʃ.ən/ bỏ sót mẫu do công cụ chờ server “Our old tool suffered from coordinated omission, so its p99 was meaningless.”
tail latency /teɪl ˈleɪ.tən.si/ latency ở đuôi phân bố “We optimise for tail latency because users feel the slowest calls.”
throughput /ˈθruː.pʊt/ số request xử lý mỗi giây “Throughput plateaued at eight hundred requests per second.”
saturation /ˌsætʃ.əˈreɪ.ʃən/ mức bão hoà, việc đang chờ “Saturation shows up as requests waiting for a connection.”
bottleneck /ˈbɑː.t̬əl.nek/ điểm nghẽn “The bottleneck moved from the pool to the database.”
warm-up /ˈwɔːrm.ʌp/ giai đoạn khởi động “We discard the first three minutes as JIT warm-up.”

Ghi chép tự tổng hợp từ tài liệu chính thức và kinh nghiệm thực tế.