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

Tìm kiếm

ConcurrencyMid23 phút đọc

Hệ điều hành cho backend: kernel, system call, process và thread

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

Cụm bài Hệ điều hành cho backend: 1. Kernel, process và thread · 2. Bộ nhớ ảo và page cache · 3. I/O model và epoll · 4. File system và shell

OS hiện ra khi có sự cố: load average 40 mà CPU rảnh, unable to create native thread dù heap còn trống, pod bị throttle dù CPU usage thấp, request bị cắt mỗi lần deploy. Bài này nói về kernel, system call, process, thread, context switch và scheduler, rồi nối chúng với JVM và container. Nên đọc trước Thread trong Java.

1. Hệ điều hành và kernel

Ý chính: kernel là lõi của hệ điều hành, chạy với quyền cao nhất và là phần duy nhất chạm thẳng vào phần cứng. Ứng dụng nhờ kernel dùng phần cứng qua system call.

Hệ điều hành quản lý tài nguyên phần cứng (CPU, RAM, đĩa, card mạng) và cung cấp dịch vụ chung cho chương trình. Kernel luôn nằm trong bộ nhớ.

flowchart TB
  A[Ứng dụng: JVM, PostgreSQL, Nginx] -->|system call| K[Kernel]
  K --> C[CPU]
  K --> M[Bộ nhớ]
  K --> D[Đĩa, card mạng]

Cần lớp ở giữa vì ba lý do:

  • Trừu tượng hoá: ứng dụng chỉ gọi read(fd, buf, n), driver lo giao thức của từng loại phần cứng.
  • Bảo vệ: ứng dụng chạy quyền thấp, không ghi được vào bộ nhớ của process khác; app lỗi chỉ chết một mình.
  • Chia sẻ: hàng trăm process dùng chung vài core, kernel chia thời gian CPU và bộ nhớ.

Kernel làm bốn việc: quản lý process/thread, quản lý bộ nhớ, quản lý thiết bị, và cung cấp system call.

2. User mode, kernel mode và system call

Ý chính: ứng dụng chạy ở user mode, nơi CPU từ chối lệnh đặc quyền. Muốn đọc file hay gửi gói tin, nó gọi system call để chuyển sang kernel mode rồi quay về.

Trên x86-64, kernel chạy ở ring 0 (kernel mode), ứng dụng ở ring 3 (user mode). Bộ nhớ cũng chia kernel space và user space. Trên Linux, vùng kernel được ánh xạ vào mọi process, nhưng các trang đó bị đánh dấu “chỉ kernel mode” trong bảng trang (phần 2).

sequenceDiagram
  participant App as Ứng dụng
  participant Libc as glibc
  participant K as Kernel
  App->>Libc: read(fd, buf, 4096)
  Libc->>K: lệnh syscall, số hiệu trong thanh ghi
  Note over K: kiểm tra quyền rồi chạy read
  K-->>Libc: sysret, trả số byte
  Libc-->>App: kết quả hoặc errno

Mỗi system call tốn ~100 ns đến vài µs, cộng phần cache bị code kernel chiếm. Cái hại là gọi quá nhiều lần: FileInputStream.read() từng byte là mỗi byte một syscall; bọc BufferedInputStream (8 KB mỗi lần) giảm 8.000 lần. Xem process gọi gì bằng strace -c -f -p <pid> (làm process chậm hẳn) hoặc nhẹ hơn là perf trace.

vDSO: đọc giờ mà không vào kernel

3. Thiết kế của Linux

Ý chính: Linux là kernel đa nhiệm, mọi CPU ngang hàng, và monolithic: hầu hết dịch vụ (scheduler, file system, network stack, driver) chạy trong kernel mode. Vì thế tối ưu I/O trên Linux là giảm số lần qua lại user/kernel.

Bốn đặc điểm thiết kế của Linux và so sánh monolithic, microkernel, hybrid
  • Multitasking: nhiều tác vụ luân phiên dùng CPU.
  • SMP: mọi CPU ngang hàng, đều chạy được code kernel và code ứng dụng, dùng chung bộ nhớ.
  • ELF: định dạng file thực thi và thư viện. Tên đúng là Executable and Linkable Format (slide ghi nhầm “Executable File Link Format”). file $(which java) in ra ELF 64-bit.
  • Monolithic kernel: scheduler, quản lý bộ nhớ, file system, network stack, driver đều chạy trong kernel mode.

4. Program, process và thread

Ý chính: process là chương trình đang chạy, có bộ nhớ riêng; thread chạy bên trong và dùng chung bộ nhớ đó. Mỗi platform thread Java là một thread OS thật, nên số thread bị OS giới hạn, không phải heap.

  • Program: file thực thi trên đĩa, dữ liệu tĩnh.
  • Process: chương trình đang chạy, có không gian địa chỉ riêng, file đang mở riêng.
  • Thread: luồng thực thi trong process. JVM có vài chục thread ngay cả khi bạn chưa tạo cái nào (GC, JIT, Finalizer…).
stateDiagram-v2
  [*] --> Created: fork
  Created --> Ready: admit
  Ready --> Running: scheduler chọn
  Running --> Ready: hết time slice
  Running --> Waiting: chờ I/O, lock, sleep
  Waiting --> Ready: được đánh thức
  Running --> Terminated: exit
  Terminated --> [*]
PCB, trạng thái trong ps, fork và copy-on-write

Kernel mô tả mỗi process bằng PCB (process control block), trên Linux là task_struct: PID, user ID, trạng thái, độ ưu tiên, con trỏ tới bảng trang, bảng file descriptor, giới hạn tài nguyên, và giá trị thanh ghi lúc bị dừng (gồm program counter, địa chỉ lệnh sắp chạy). Đọc được qua /proc/<pid>/status, limits, fd/.

Trạng thái trong ps/top:

  • R: đang chạy hoặc chờ CPU.
  • S: ngủ chờ sự kiện (socket, lock).
  • D: chờ I/O không ngắt được (đĩa, NFS).
  • Z: zombie (đã chết, cha chưa đọc exit code).
  • T: bị dừng.

Linux tạo process bằng fork() (nhân bản process hiện tại) rồi exec() (thay bằng chương trình khác). Nhân bản bộ nhớ không đắt nhờ copy-on-write: cha và con dùng chung trang nhớ, chỉ trang nào bị ghi mới được sao chép. Redis dùng đúng cơ chế này để snapshot (BGSAVE), nên khi tải ghi cao, RAM thực tế lúc snapshot có thể tăng gần gấp đôi.

Thread trong cùng process dùng chung code, heap, file và socket; mỗi thread có thanh ghi, stack và thread-local riêng.

Process Thread
Không gian địa chỉ riêng chung
Giao tiếp IPC: pipe, socket chung bộ nhớ, cần đồng bộ
Một bên lỗi bên kia không sao có thể chết cả process
Context switch đổi bảng trang, mất TLB không đổi bảng trang

(TLB: bộ nhớ đệm của CPU lưu các bản dịch địa chỉ ảo sang địa chỉ thật.)

Mỗi platform thread của Java ánh xạ 1:1 với một thread OS (pthread_create rồi clone). Hệ quả:

  • Mỗi thread có stack native, mặc định 1 MB bộ nhớ ảo trên Linux x64 (-Xss); chỉ phần dùng thật mới tốn RAM.
  • Lập lịch do kernel quyết định (setPriority gần như vô tác dụng trên Linux).
  • Số thread bị giới hạn bởi OS chứ không bởi heap.

Virtual thread (Java 21) là mô hình M:N: rất nhiều virtual thread chạy trên vài carrier thread (mặc định bằng số CPU). Khi chờ I/O, JVM tháo virtual thread khỏi carrier và cất stack lên heap; kernel không hề context switch. Chi tiết ở ExecutorService, thread pool và virtual thread.

5. Context switch và scheduler

Ý chính: một core chạy một thread tại một thời điểm; đổi thread là context switch, tốn 1–5 µs trực tiếp và nhiều hơn vì cache nguội. Scheduler của Linux chia CPU công bằng theo time slice vài ms.

Khi context switch, kernel lưu thanh ghi và program counter của thread cũ vào task_struct, rồi nạp thanh ghi của thread mới. Khác process thì còn đổi bảng trang và mất một phần TLB. Chi phí gián tiếp lớn hơn vì cache L1/L2 còn đầy dữ liệu của thread cũ.

Có hai loại:

  • Voluntary: thread tự nhường vì phải chờ (I/O, lock, park). Nhiều là dấu hiệu chờ I/O hoặc tranh lock.
  • Involuntary: thread còn muốn chạy nhưng hết time slice. Nhiều là dấu hiệu oversubscription (nhiều thread cần CPU hơn số core) hoặc bị CPU quota hãm.
vmstat 1                       # cs: context switch/giây của cả máy, r: số task chờ CPU
pidstat -w -t -p <pid> 1       # cswch/s và nvcswch/s cho từng thread
grep ctxt /proc/<pid>/status   # tổng tích luỹ của thread chính
Scheduler của Linux: CFS, EEVDF, time slice và nice

Từ 2007 đến Linux 6.5 là CFS: mỗi task có vruntime (thời gian đã chạy, có trọng số), task sẵn sàng nằm trong cây đỏ đen, luôn chọn task có vruntime nhỏ nhất. Từ Linux 6.6 (2023) là EEVDF: vẫn chia công bằng nhưng thêm “hạn chót ảo” để task cần độ trễ thấp được chạy sớm.

Ý tưởng chung:

  • Mỗi CPU có một run queue (hàng đợi task chờ CPU).
  • Time slice cỡ vài ms và ngắn lại khi nhiều task chờ.
  • nice từ -20 đến 19 đổi trọng số. Chạy job batch với nice -n 10 để nhường service chính.

Load average là số task trung bình đang chạy hoặc chờ CPU, và trên Linux tính cả task D (chờ đĩa, không ngắt được). Vì thế load 40 trên máy 8 core mà CPU rảnh thường là nghẽn đĩa hoặc NFS: xem cột wa và b của vmstat, rồi iostat -x 1.

Concurrency là nhiều việc cùng tiến triển (có thể luân phiên trên một core); parallelism là nhiều việc chạy cùng lúc trên nhiều core. Slide nêu nguyên tắc: trên một core, chạy A rồi B luôn nhanh hơn chạy xen kẽ. Nguyên tắc này chỉ đúng một nửa.

6. Process trong container: CPU quota, số CPU và signal

Ý chính: CPU limit là quota theo từng chu kỳ 100 ms, nên container bị đóng băng được dù usage trung bình thấp. Java phải là PID 1 (hoặc được chuyển tiếp SIGTERM) thì mới graceful shutdown.

resources.limits.cpu: 1 của Kubernetes thành cpu.max = 100000 100000 trong cgroup: mỗi chu kỳ 100 ms, mọi thread của container cộng lại được dùng 100 ms CPU. Nhiều core vô ích: 8 thread trên 8 core tiêu hết quota sau 12,5 ms, rồi cả container bị đóng băng 87,5 ms còn lại.

JVM từ JDK 10 (và 8u191) nhận biết container: availableProcessors() tính từ quota của cgroup, không phải số core của node. Con số này quyết định số thread GC, kích thước ForkJoinPool.commonPool(), số carrier của virtual thread, số event loop của Netty. Ghi đè bằng -XX:ActiveProcessorCount=N. Chỉ CPU limit ảnh hưởng con số này; không đặt limit thì JVM thấy mọi core của node. Đóng gói thành image cho đúng (Dockerfile nhiều stage, MaxRAMPercentage, non-root, ENTRYPOINT dạng exec) có ở Docker cho Spring Boot.

Signal và PID 1. Khi dừng pod, Kubernetes gửi SIGTERM tới PID 1 của container, chờ terminationGracePeriodSeconds (mặc định 30 giây), rồi gửi SIGKILL. Exit code 143 là chết vì SIGTERM, 137 là SIGKILL (hoặc OOM killer, phần 2). JVM bắt SIGTERM và chạy shutdown hook; với server.shutdown=graceful, Spring Boot ngừng nhận request mới, chờ request đang chạy xong (tối đa spring.lifecycle.timeout-per-shutdown-phase), rồi đóng các bean. SIGTERM, readiness và preStop ghép lại thành rolling update không rớt request ra sao có ở Chiến lược deploy.

Bài tập

Code chạy bằng JDK 21; số liệu của máy mình chỉ để thấy bậc độ lớn (cần số tin cậy thì dùng JMH).

Bài 1: Chi phí tạo thread và đánh thức thread

Đề. Đo (a) thời gian tạo, start và join một platform thread so với virtual thread; (b) thời gian một lần “chuyền bóng” giữa hai platform thread (một thread ngủ, thread kia được đánh thức).

Lời giải bài 1: code, số đo và giải thích
import java.util.concurrent.locks.LockSupport;

public class ThreadCost {
    static final int N = 10_000;
    static volatile int turn = 0;

    public static void main(String[] args) throws Exception {
        for (int r = 0; r < 3; r++)
            System.out.printf("platform %.1f us, virtual %.2f us, handoff %.2f us%n",
                    startJoin(Thread.ofPlatform()), startJoin(Thread.ofVirtual()), pingPong());
    }

    static double startJoin(Thread.Builder builder) throws InterruptedException {
        Thread[] ts = new Thread[N];
        long t0 = System.nanoTime();
        for (int i = 0; i < N; i++) ts[i] = builder.start(() -> {});
        for (Thread t : ts) t.join();
        return (System.nanoTime() - t0) / 1_000.0 / N;
    }

    static double pingPong() throws InterruptedException {
        int rounds = 100_000;
        Thread[] pair = new Thread[2];
        for (int id = 0; id < 2; id++) {
            int me = id;
            pair[id] = Thread.ofPlatform().unstarted(() -> {
                for (int i = 0; i < rounds; i++) {
                    while (turn != me) LockSupport.park();   // ngủ tới lượt mình
                    turn = 1 - me;
                    LockSupport.unpark(pair[1 - me]);        // đánh thức thread kia
                }
            });
        }
        turn = 0;
        long t0 = System.nanoTime();
        pair[0].start(); pair[1].start();
        pair[0].join(); pair[1].join();
        return (System.nanoTime() - t0) / 1_000.0 / (2.0 * rounds);
    }
}
Môi trường Platform thread Virtual thread Một lần chuyền
macOS, Apple M4, 10 core 23–28 µs 0,2–1,7 µs 1,7–1,9 µs
Linux container --cpus=1 20–124 µs 0,8–2,8 µs 0,9–3,2 µs

Giải thích. Platform thread cần clone(), cấp stack native và task_struct, nên đắt hơn virtual thread (một object trên heap) 20–50 lần. Một lần chuyền 1–3 µs là giá của “ngủ, được đánh thức, được lập lịch lại”. Bài học: đừng tạo platform thread cho mỗi request; dùng pool, hoặc virtual thread khi việc chủ yếu là chờ I/O.

Bài 2: Tuần tự hay xen kẽ trên một CPU

Đề. Kiểm chứng nguyên tắc “trên một core, tuần tự nhanh hơn xen kẽ”: 16 việc CPU-bound giống nhau, chạy bằng pool 1 thread và pool 16 thread trong container giới hạn 1 CPU. Đo tổng thời gian, lúc việc đầu tiên xong, và thời gian hoàn thành trung bình.

Lời giải bài 2: code, hai lần chạy và giải thích
import java.util.*;
import java.util.concurrent.*;

// docker run --rm --cpus=1 -v $PWD:/lab -w /lab eclipse-temurin:21-jdk java TimeSlicing.java
public class TimeSlicing {
    static long work() {
        long x = 0;
        for (int i = 0; i < 40_000_000; i++) x += (x ^ i) * 31 + 7;
        return x;
    }

    public static void main(String[] args) throws Exception {
        work(); work(); // làm nóng JIT
        for (int pool : new int[] {1, 16}) {
            ExecutorService ex = Executors.newFixedThreadPool(pool);
            long t0 = System.nanoTime();
            long[] done = new long[16];
            List<Future<?>> fs = new ArrayList<>();
            for (int i = 0; i < 16; i++) {
                int id = i;
                fs.add(ex.submit(() -> { work(); done[id] = System.nanoTime(); }));
            }
            for (Future<?> f : fs) f.get();
            var s = Arrays.stream(done).mapToDouble(d -> (d - t0) / 1e6).summaryStatistics();
            System.out.printf("pool=%2d total=%4.0f ms | first=%4.0f ms | avg=%4.0f ms%n",
                    pool, s.getMax(), s.getMin(), s.getAverage());
            ex.shutdown();
        }
    }
}

Hai lần chạy (availableProcessors=1):

pool= 1 total= 818 ms | first=  54 ms | avg= 437 ms
pool=16 total= 847 ms | first= 448 ms | avg= 800 ms

pool= 1 total= 977 ms | first=  82 ms | avg= 546 ms
pool=16 total=1087 ms | first= 616 ms | avg=1021 ms

Giải thích. Tổng thời gian gần như bằng nhau (xen kẽ chậm hơn 3–10% vì context switch và cache nguội), nhưng thời gian hoàn thành trung bình tệ gần gấp đôi: 16 việc chia nhau một CPU nên việc nào cũng xong gần cuối.

Sau khi chạy, cpu.stat của container báo nr_periods 24, nr_throttled 13, throttled_usec 1062903: máy ảo có 2 vCPU, JIT, GC và thread làm việc chạy song song nên đốt quota rất nhanh.

Bài 3: Sửa Dockerfile để graceful shutdown hoạt động

Đề. Mỗi lần deploy Dockerfile dưới đây lên Kubernetes, khoảng 0,5% request lỗi 502 và log không có dòng “Commencing graceful shutdown”. Vì sao, sửa thế nào?

FROM eclipse-temurin:21-jre
COPY app.jar /app/app.jar
ENTRYPOINT java $JAVA_OPTS -jar /app/app.jar
Lời giải bài 3: exec form và cấu hình graceful shutdown

Dạng shell khiến /bin/sh -c là PID 1; SIGTERM không tới Java, Spring không graceful shutdown, pod bị SIGKILL sau 30 giây. Sửa thành ENTRYPOINT ["sh", "-c", "exec java $JAVA_OPTS -jar /app/app.jar"].

Kèm theo:

  • server.shutdown: graceful, spring.lifecycle.timeout-per-shutdown-phase: 20s, terminationGracePeriodSeconds: 40.
  • preStop sleep 5, vì việc gỡ endpoint khỏi Service chạy song song với SIGTERM.

Kiểm chứng bằng kubectl delete pod: log có “Graceful shutdown complete”, exit code 143 hoặc 0, không phải 137.

Ghi nhớ

  • Giải thích được vì sao system call là trap chứ không phải interrupt, và vì sao đọc từng byte không buffer lại chậm.
  • Phân biệt được process, thread (với kernel Linux), platform thread và virtual thread.
  • Biết khi nào load average cao là thiếu CPU, khi nào là nghẽn đĩa.
  • Giải thích được vì sao pod dùng 40% CPU limit vẫn bị throttle, và JVM thấy bao nhiêu CPU trong container.
  • Biết vì sao ENTRYPOINT dạng shell làm hỏng graceful shutdown và sửa thế nào.

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

Junior

Process và thread khác nhau thế nào?

Process có không gian địa chỉ riêng và cách ly với process khác; thread chạy bên trong process và dùng chung bộ nhớ với các thread khác.

Thread dùng chung heap, code, file đang mở, nhưng có stack và thanh ghi riêng. Thread rẻ hơn để tạo và để chuyển, nhưng chung bộ nhớ nên phải đồng bộ, và một thread làm hỏng trạng thái chung có thể làm chết cả process.

System call là gì? Cho ví dụ trong Java.

Là cách ứng dụng ở user mode nhờ kernel làm việc cần quyền cao: read, write, socket, connect, mmap, clone.

Trong Java, FileInputStream.read, Socket.connect, new Thread().start() đều dẫn tới system call qua JVM và glibc. Mỗi lần gọi phải chuyển sang kernel mode và quay lại, nên gọi quá dày (đọc từng byte không buffer) sẽ chậm.

Concurrency và parallelism khác nhau thế nào?

Concurrency là nhiều việc cùng tiến triển, có thể chỉ bằng luân phiên trên một core; parallelism là nhiều việc chạy cùng thời điểm trên nhiều core.

Server xử lý 1.000 request trên 4 core vừa concurrent (1.000 request cùng dở dang) vừa parallel (tối đa 4 việc chạy cùng lúc).

Mid

Context switch tốn gì? Vì sao switch giữa thread rẻ hơn giữa process?

Trực tiếp khoảng 1–5 µs, gián tiếp (cache, TLB nguội) thường lớn hơn; thread cùng process dùng chung bảng trang nên không mất TLB.

Phần trực tiếp gồm vào kernel, chạy scheduler, lưu và nạp thanh ghi. Hai process khác nhau phải đổi bảng trang. Đo bằng cột cs của vmstat và pidstat -w (voluntary/involuntary theo thread).

Load average 30 trên máy 8 core có phải là thiếu CPU?

Chưa chắc: trên Linux, load average đếm cả task chờ CPU và task D chờ I/O không ngắt được.

CPU idle cao và wa cao nghĩa là nghẽn đĩa hoặc NFS. Chỉ khi CPU gần 100% và cột r của vmstat lớn hơn nhiều số core mới là thiếu CPU. Xem thêm iostat -x và đếm task D.

Thread Java ánh xạ với thread OS thế nào? Virtual thread khác gì?

Platform thread là 1:1 với thread OS; virtual thread là M:N trên vài carrier thread.

Platform thread có stack native (1 MB ảo mặc định), do kernel lập lịch, tạo tốn vài chục µs, số lượng bị OS và cgroup giới hạn. Khi virtual thread chờ I/O, JVM tháo nó khỏi carrier và cất stack lên heap, kernel không phải context switch. Hợp với việc chờ I/O nhiều, không giúp việc CPU-bound.

Vì sao unable to create native thread xảy ra dù heap còn trống?

Vì OS từ chối tạo thread native, không liên quan heap.

Nguyên nhân: chạm ulimit -u, pids.max của cgroup, kernel.threads-max, hoặc hết bộ nhớ ảo cho stack. Gốc rễ thường là tạo thread không giới hạn. Đếm thread qua /proc/<pid>/task hoặc thread dump, rồi dùng pool có giới hạn hoặc virtual thread; tăng -Xmx không giúp.

Senior

Pod dùng 40% CPU limit nhưng p99 tăng vọt theo đợt. Điều tra thế nào?

Nghi CPU throttling: limit là quota theo chu kỳ 100 ms, còn usage là trung bình theo phút.

GC song song, JIT và pool lớn có thể đốt hết quota trong vài ms đầu chu kỳ. Kiểm tra nr_throttled, throttled_usec trong cpu.stat hoặc container_cpu_cfs_throttled_periods_total, đối chiếu với GC log. Xử lý: giảm thread song song cho khớp limit (ParallelGCThreads, ActiveProcessorCount, kích thước pool), tăng limit, hoặc chỉ đặt request cho service nhạy độ trễ.

Bạn chọn số thread cho pool thế nào, dựa trên hiểu biết về scheduler?

Tách loại việc: CPU-bound cỡ availableProcessors, chờ I/O thì nhiều hơn theo tỉ lệ chờ/tính, rồi đo để chỉnh.

  • CPU-bound: khoảng bằng availableProcessors (đã tính CPU limit); nhiều hơn chỉ thêm context switch.
  • Chờ I/O: xấp xỉ số core × (1 + thời gian chờ / thời gian tính), giới hạn bởi tài nguyên phía sau (connection pool, rate limit của đối tác); hoặc virtual thread kèm semaphore.
  • Đo: nvcswch/s cao và run queue dài là thừa thread; CPU thấp mà latency cao là thiếu thread hoặc nghẽn phía sau.
Mỗi lần deploy có vài request lỗi 502 và log không có dòng graceful shutdown. Vì sao?

Java không nhận SIGTERM, thường vì ENTRYPOINT dạng shell khiến sh là PID 1 và không chuyển tiếp signal; pod bị SIGKILL sau grace period (exit 137).

Sửa bằng dạng exec, exec java ... hoặc tini. Thêm server.shutdown=graceful, timeout của Spring nhỏ hơn terminationGracePeriodSeconds, và preStop sleep vài giây vì việc gỡ endpoint chạy song song với SIGTERM.

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
kernel /ˈkɜːnl/ lõi hệ điều hành “Only the kernel talks to the hardware directly.”
system call /ˈsɪstəm kɔːl/ lời gọi nhờ kernel làm việc cần quyền cao “Every unbuffered read is a system call.”
kernel mode /ˈkɜːnl məʊd/ chế độ quyền cao của CPU “A syscall switches the CPU into kernel mode.”
trap /træp/ chuyển sang kernel có chủ đích “A syscall is a trap, not a hardware interrupt.”
context switch /ˈkɒntekst swɪtʃ/ chuyển CPU sang thread khác “Too many runnable threads cause involuntary context switches.”
run queue /rʌn kjuː/ hàng đợi task chờ CPU “A long run queue means we’re short on CPU.”
oversubscription /ˌəʊvəsəbˈskrɪpʃn/ nhiều thread cần CPU hơn số core “Oversubscription adds switches, not throughput.”
load average /ləʊd ˈævərɪdʒ/ số task trung bình đang chạy hoặc chờ “On Linux, load average also counts tasks blocked on disk.”
copy-on-write /ˈkɒpi ɒn raɪt/ chỉ sao chép trang khi bị ghi “Fork is cheap thanks to copy-on-write.”
throttling /ˈθrɒtlɪŋ/ bị hãm vì hết quota “The pod was throttled at forty percent average usage.”
graceful shutdown /ˈɡreɪsfl ˈʃʌtdaʊn/ tắt êm, làm xong việc đang dở “Graceful shutdown needs the JVM to receive SIGTERM.”

Ghi chép dựa trên khoá Advanced Backend (Ronin Engineer), viết lại theo cách hiểu của mình.