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

Tìm kiếm

System DesignSenior24 phút đọc

I/O model: blocking, non-blocking, epoll và file descriptor

Ôn 22 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

Phần lớn thời gian của một request backend là chờ database, Redis, API khác, đĩa. Cách chương trình chờ quyết định server chịu được 200 hay 50.000 kết nối. Đọc xong, bạn giải thích được epoll, Tomcat, Netty, virtual thread, fsync và “Too many open files”. Nên đọc trước phần 1 (system call, context switch) và phần 2 (page cache).

1. I/O đi qua những tầng nào

Ý chính: I/O là trao đổi dữ liệu với bên ngoài (đĩa, mạng, ngoại vi) qua kernel. Phần đắt nhất không phải system call mà là thời gian chờ thiết bị.

Đọc ghi RAM không phải I/O vì CPU truy cập RAM trực tiếp. Một lệnh đọc đi qua sáu bước:

  1. Ứng dụng cần dữ liệu, ví dụ in.read(buf).
  2. Thư viện gọi system call (read, recv), CPU chuyển sang kernel mode.
  3. Kernel ra lệnh cho thiết bị qua driver.
  4. Dữ liệu vào RAM bằng DMA (Direct Memory Access): bộ điều khiển thiết bị tự chép, CPU không phải chép từng byte.
  5. Xong việc, thiết bị báo CPU bằng interrupt (tín hiệu ngắt); kernel đánh thức thread đang chờ.
  6. Kernel chép dữ liệu từ buffer kernel sang buffer ứng dụng, system call trả về.
sequenceDiagram
    participant App as Thread ứng dụng
    participant K as Kernel
    participant D as Thiết bị
    App->>K: read() - vào kernel mode
    K->>D: ra lệnh qua driver
    Note over App,K: thread chờ, CPU chạy việc khác
    D-->>K: DMA chép vào RAM rồi gửi interrupt
    K-->>App: chép sang buffer app, read() trả về

Mỗi system call tốn dưới một tới vài microsecond; chờ thiết bị lâu hơn hàng nghìn lần: đọc ngẫu nhiên HDD 5–10 ms, round-trip trong datacenter 0,1–0,5 ms. Câu hỏi của cả bài: trong lúc chờ, thread của bạn làm gì?

2. Bốn nhóm nút thắt và cách đo

Ý chính: nút thắt rơi vào CPU, bộ nhớ, đĩa hoặc mạng; đo bằng công cụ của từng nhóm trước khi đoán.

Nhóm Nguyên nhân hay gặp Đo bằng (Linux)
CPU tính toán nặng, GC, quá nhiều context switch top, vmstat 1 (cột r, cs), pidstat -w 1
Memory thiếu RAM, swap free -m, vmstat 1 (si, so), dmesg tìm OOM killer
Disk IOPS, I/O ngẫu nhiên, phân mảnh iostat -x 1 (r_await, w_await, aqu-sz)
Network băng thông, mô hình I/O, kết nối ss -s, ss -tan, sar -n DEV 1, nstat (retransmit)
Đọc đúng iowait, %util và thread dump

Với JVM thêm thread dump (jcmd <pid> Thread.print): 180/200 thread đứng ở NioSocketImpl.read là đang chờ dependency.

3. Năm mô hình I/O của Unix

Ý chính: một lần đọc mạng có hai pha: chờ dữ liệu tới kernel, rồi chép sang ứng dụng. Mô hình I/O khác nhau ở chỗ pha nào chặn thread.

Mô hình Pha 1: chờ dữ liệu Pha 2: chép Ví dụ
Blocking chặn chặn InputStream.read(), JDBC
Non-blocking trả về ngay EAGAIN, tự hỏi lại chặn (ngắn) socket O_NONBLOCK
Multiplexing chặn ở select/poll/epoll_wait cho nhiều fd chặn (ngắn) Java NIO, Netty, Nginx, Redis
Signal-driven kernel gửi SIGIO chặn (ngắn) hiếm dùng
Asynchronous không chặn không chặn, kernel chép xong mới báo io_uring, Windows IOCP

Bốn mô hình đầu đều là synchronous theo POSIX: lúc chép dữ liệu thread vẫn đứng chờ. Slide vẽ “synchronous non-blocking” và “asynchronous”; cần tách bạch hai từ:

  • Non-blocking: call trả về ngay, có thể với “chưa có gì”.
  • Asynchronous: kết quả tới sau qua callback hoặc completion queue (hàng đợi báo xong).

4. Hai đoạn code Java trong slide

Ý chính: cả hai ví dụ của slide đều sai: đoạn “blocking” tốn một system call mỗi byte, đoạn “non-blocking” là async API bị busy-wait.

Slide minh hoạ blocking I/O bằng vòng đọc FileInputStream:

while ((content = fis.read()) != -1) {
    System.out.print((char) content);
}

Lỗi lớn hơn blocking: không có buffer nên mỗi byte là một system call. Thêm nữa, ép byte sang char sai với UTF-8, và thiếu try-with-resources. Bài tập 1 đo con số cụ thể.

Đoạn AsynchronousFileChannel của slide và vì sao file không có non-blocking

Slide minh hoạ non-blocking I/O bằng AsynchronousFileChannel:

Future<Integer> result = fileChannel.read(buffer, 0);
while (!result.isDone()) {
    System.out.println("Doing something else while reading...");
}

Ba điều cần sửa:

  • Đây là async API trả về Future, không phải non-blocking.
  • Vòng while là busy-wait (vòng lặp hỏi liên tục): đốt trọn một core và in hàng nghìn dòng, mỗi dòng lại một system call. Có việc thì làm việc đó rồi gọi result.get(), hoặc dùng CompletionHandler.
  • Trên Linux, macOS, AsynchronousFileChannel được giả lập bằng thread pool chạy pread blocking; chỉ Windows dùng I/O overlapped thật.

5. Một server phục vụ được bao nhiêu kết nối?

Ý chính: giới hạn thật là số file descriptor, bộ nhớ và mô hình threading, không phải số port. Với Java truyền thống, mô hình “một thread một kết nối” chạm trần trước.

  • File descriptor (fd): mỗi socket là một fd. Soft limit ulimit -n hay là 1024 trong shell; service systemd lấy theo LimitNOFILE.
  • Bộ nhớ: kết nối TCP rảnh tốn vài tới vài chục KB. C10K (mười nghìn kết nối) đã là chuyện cũ.
  • Mô hình threading: pool 200 thread thì request thứ 201 xếp hàng dù CPU rảnh.

Một hệ thống sống nhờ kết nối mở lâu: WebSocket gateway giữ 10 triệu kết nối đồng thời trong Thiết kế hệ thống chat kiểu Discord.

Chi tiết giới hạn fd, buffer TCP và ephemeral port

File descriptor. Container theo cấu hình runtime, thường rất cao; toàn hệ thống có fs.file-max, fs.nr_open. HotSpot mặc định nâng soft limit lên bằng hard limit khi khởi động (-XX:+MaxFDLimit), nên với JVM con số đáng nhìn thường là hard limit.

Bộ nhớ. Mỗi kết nối TCP có buffer trong kernel (tcp_rmem/tcp_wmem, tự co giãn) cộng buffer ứng dụng.

Threading. “Một kết nối, một thread” bắt thread vừa chờ I/O, vừa parse, vừa chạy logic. Tạo huỷ thread liên tục thì tốn, nên dùng pool, và pool chính là trần.

6. select, poll và epoll

Ý chính: multiplexing là một thread hỏi kernel “trong N socket này, cái nào có dữ liệu?”. epoll thắng select/poll vì đăng ký một lần và chỉ trả về fd sẵn sàng.

  • select: bitmap tối đa 1024 fd (FD_SETSIZE), mỗi lần gọi chép cả tập vào kernel và duyệt N fd: O(N).
  • poll: bỏ giới hạn 1024, vẫn O(N) mỗi lần.
  • epoll tách đăng ký khỏi chờ:
    • epoll_create1 tạo đối tượng epoll (cũng là một fd).
    • epoll_ctl thêm/bỏ socket khỏi tập quan tâm (interest set, lưu trong cây đỏ đen), một lần cho mỗi kết nối.
    • Có dữ liệu thì kernel callback đưa socket vào ready list.
    • epoll_wait chỉ chép ready list ra: chi phí theo số fd sẵn sàng.
flowchart LR
    B[epoll_ctl ADD socket] --> T[Interest set - cây đỏ đen]
    N[NIC nhận gói tin] -->|callback| R[Ready list]
    T -.-> R
    R -->|epoll_wait| L[Event loop xử lý fd sẵn sàng]

macOS/BSD dùng kqueue, Windows dùng IOCP (mô hình completion).

Selector của Java trên từng OS và level- vs edge-triggered

7. Từ epoll tới Tomcat, Netty và virtual thread

Ý chính: cả ba đều dựa trên epoll, khác ở chỗ code của bạn chạy trên thread nào. Tomcat dùng worker pool, Netty chạy handler trên event loop, virtual thread để runtime tự multiplex.

Tomcat NIO connector (mặc định của Spring Boot):

  • Thread Acceptor nhận kết nối.
  • Thread Poller giữ Selector cho mọi kết nối mở, kể cả keep-alive đang rảnh.
  • Khi có request, worker pool (server.tomcat.threads.max, mặc định 200) chạy servlet kiểu blocking.

Vì vậy Tomcat giữ được 8.192 kết nối (max-connections) nhưng chỉ xử lý 200 request đồng thời.

Netty (nền của WebFlux, gRPC Java): vài event loop, mỗi cái một thread với một Selector, phục vụ hàng nghìn channel. Handler chạy ngay trên event loop, nên tuyệt đối không được chặn nó. Đây là Reactor pattern: event loop chờ fd sẵn sàng rồi phân phát sự kiện cho handler. Đừng nhầm với Actor model, nơi mỗi actor có state riêng và một mailbox, chỉ giao tiếp bằng message (Akka, Erlang). gRPC Java chạy HTTP/2 trên Netty; chọn REST hay gRPC giữa các service ở Giao tiếp đồng bộ: REST, gRPC, HTTP/2.

Virtual thread (Java 21) giữ code blocking. Khi virtual thread đọc socket chưa có dữ liệu, JDK:

  1. đặt socket non-blocking và đăng ký fd với một poller nội bộ (trên Linux là epoll);
  2. park virtual thread (tạm cất nó đi) và trả carrier thread cho scheduler;
  3. khi epoll báo sẵn sàng, poller unpark và virtual thread chạy tiếp trên carrier bất kỳ.

Hai ngoại lệ: file I/O không non-blocking nên chiếm carrier (scheduler bù bằng carrier tạm), và ở Java 21 I/O bên trong synchronized gây pinning (sửa ở Java 24, JEP 491). Chi tiết pinning ở bài ExecutorService và virtual thread.

# Spring Boot 3.2+: worker của Tomcat chạy trên virtual thread
spring.threads.virtual.enabled=true

Trần 200 worker biến mất nhưng dời sang connection pool (HikariCP mặc định 10): back-pressure (tự hãm khi quá tải) đúng chỗ, miễn có timeout khi lấy kết nối. Chọn kích thước pool và đặt connectionTimeout thế nào có ở Connection pool và HikariCP.

8. Đĩa: tuần tự, ngẫu nhiên, page cache và fsync

Ý chính: đọc tuần tự nhanh hơn ngẫu nhiên rất nhiều, nên hệ thống ghi nhiều đều append. write() chỉ ghi vào page cache; muốn dữ liệu sống sót khi mất điện phải fsync.

Slide nói tuần tự nhanh hơn ngẫu nhiên 3–4 lần; thực tế HDD chênh hàng trăm lần, NVMe đọc từng cái một vẫn chênh hàng chục lần. Vì thế Kafka, WAL của PostgreSQL, redo log InnoDB và LSM-tree đều chỉ append (xem Vì sao Kafka nhanh).

  • Đường đọc đi qua page cache: trúng cache thì chỉ là chép bộ nhớ.
  • Đường ghi: write() chép vào page cache, đánh dấu dirty (chưa xuống đĩa) rồi trả về. Kernel flush sau khoảng 30 giây (hoặc khi trang dirty vượt vm.dirty_background_ratio); mất điện trước đó là mất dữ liệu “đã ghi thành công”.
  • fsync (Java: FileChannel.force(true), hoặc mở với StandardOpenOption.DSYNC) ép dữ liệu xuống đĩa. Nó tốn từ dưới 1 ms (NVMe có tụ bảo vệ) tới hàng chục ms (HDD), nên database gom nhiều transaction vào một lần fsync (group commit).
Bảng IOPS của HDD, SSD, NVMe và chuyện fsyncgate

Slide nói “đĩa chậm” là hiểu lầm: ý này chỉ đúng một nửa.

Thiết bị Đọc ngẫu nhiên 4 KB Đọc tuần tự
HDD 7.200 rpm ~100–200 IOPS (~0,5–1 MB/s) ~150–250 MB/s
SATA SSD ~50–100 nghìn IOPS (queue sâu) ~500 MB/s
NVMe SSD hàng trăm nghìn IOPS (queue sâu); ~10–20 nghìn ở queue depth 1 3–7 GB/s

Tuần tự vẫn thắng cả trên SSD vì ít request hơn và có readahead (kernel đọc trước phần kế tiếp).

9. File descriptor và “Too many open files”

Ý chính: file descriptor là số nguyên kernel cấp cho mỗi thứ process mở. “Too many open files” (EMFILE) có hai nguyên nhân rất khác: limit quá thấp so với tải thật, hoặc rò rỉ fd.

Trong Linux mọi thứ là file: file thường, socket, pipe, thiết bị, cả epoll. fd là chỉ số trong bảng fd của process (0, 1, 2 là stdin, stdout, stderr). Xem fd đang mở ở /proc/<pid>/fd hoặc lsof -p <pid>; inode và link ở phần 4.

Nhìn lịch sử số fd: lên xuống theo tải là limit thấp, tăng đều khi tải không đổi là rò rỉ.

Bài tập

Chạy bằng JDK 21 trên macOS, trong thư mục tạm ngoài repo.

Bài 1: Đọc file có buffer và không buffer

Đề: tạo file ~20 MB, đọc theo ba cách (từng byte không buffer, từng byte qua BufferedInputStream, theo khối 64 KB), so thời gian và giải thích.

Kết quả: không buffer ~7,4 giây, BufferedInputStream ~100 ms, đọc khối ~9 ms; chênh do số system call, không phải đĩa.

Lời giải Bài 1: code và số đo
static long unbuffered(Path file) throws IOException {
    long sum = 0;
    try (InputStream in = new FileInputStream(file.toFile())) {
        int b;
        while ((b = in.read()) != -1) sum += b;          // 1 system call mỗi byte
    }
    return sum;
}

static long chunked(Path file) throws IOException {
    long sum = 0;
    byte[] chunk = new byte[64 * 1024];
    try (InputStream in = Files.newInputStream(file)) {
        for (int n; (n = in.read(chunk)) != -1; )
            for (int i = 0; i < n; i++) sum += chunk[i] & 0xff;
    }
    return sum;
}

Bản thứ hai giống unbuffered nhưng bọc new BufferedInputStream(..., 64 * 1024). main tạo file bằng new Random(42).nextBytes(...), chạy mỗi cách hai vòng, đo bằng System.nanoTime().

Kết quả (checksum giống nhau): không buffer 7.244 và 7.523 ms; BufferedInputStream 104 và 102 ms; đọc khối 9 và 8 ms. Số system call là 20 triệu so với ~320. Bản BufferedInputStream vẫn chậm hơn bản đọc khối vì mỗi byte vẫn qua một lời gọi method có khoá bên trong. Benchmark nghiêm túc nên dùng JMH; ở đây chênh lệch đủ lớn để không cần.

Bài 2: Echo server một thread bằng NIO Selector

Đề: server echo dùng một thread phục vụ nhiều kết nối, thử với 200 client đồng thời.

Lời giải Bài 2: EchoServer và kết quả chạy
public class EchoServer {
    public static void main(String[] args) throws IOException {
        try (Selector selector = Selector.open();
             ServerSocketChannel server = ServerSocketChannel.open()) {
            server.bind(new InetSocketAddress("127.0.0.1", 9090));
            server.configureBlocking(false);                 // bắt buộc trước khi register
            server.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("selector = " + selector.getClass().getSimpleName());
            while (true) {
                selector.select();                           // epoll_wait hoặc kevent
                Iterator<SelectionKey> it = selector.selectedKeys().iterator();
                while (it.hasNext()) {
                    SelectionKey key = it.next();
                    it.remove();                             // quên dòng này thì key cũ bị xử lý lại
                    if (key.isAcceptable()) {
                        SocketChannel c = server.accept();
                        c.configureBlocking(false);
                        c.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                    } else if (key.isReadable()) {
                        echo(key);                           // bản đầy đủ: catch IOException, cancel key, đóng channel
                    }
                }
            }
        }
    }

    static void echo(SelectionKey key) throws IOException {
        SocketChannel c = (SocketChannel) key.channel();
        ByteBuffer buf = (ByteBuffer) key.attachment();
        if (c.read(buf) == -1) { key.cancel(); c.close(); return; }   // client đã đóng
        buf.flip();
        c.write(buf);                                        // demo: giả sử ghi hết một lần
        buf.compact();
    }
}

Client mở 200 socket cùng lúc, gửi hello-i trên từng cái và đọc lại: 200/200 echoed correctly by one server thread; printf 'ping\n' | nc -w 1 127.0.0.1 9090 trả về ping. Trên macOS chương trình in KQueueSelectorImpl, trên Linux sẽ là EPollSelectorImpl.

Chỗ đã đơn giản hoá: write có thể không ghi hết khi buffer gửi đầy (phải giữ phần dư và đăng ký OP_WRITE), và xử lý nặng phải ra khỏi thread selector. Netty làm hộ những thứ này.

Bài 3: Tạo và chẩn đoán rò rỉ file descriptor

Đề: viết code rò fd, chạy với limit thấp, chẩn đoán bằng công cụ hệ điều hành.

Lời giải Bài 3: code rò fd, lsof và cách sửa
static final List<Object> keepAlive = new ArrayList<>();    // giả lập reader bị giữ, không bao giờ close

static String readFirstLineLeaky(Path p) throws IOException {
    BufferedReader r = Files.newBufferedReader(p);          // BUG: không có try-with-resources
    keepAlive.add(r);
    return r.readLine();
}
// main: gọi readFirstLineLeaky trong vòng lặp vô hạn, bắt IOException, in số lần đọc rồi sleep 10 giây

Chạy với ulimit -n 1024 và java -XX:-MaxFDLimit (để JVM không tự nâng soft limit):

failed after 1020 reads: java.nio.file.FileSystemException: config.txt: Too many open files
$ lsof -p <pid> | awk 'NR>1 {print $5, $NF}' | sort | uniq -c | sort -rn | head -2
1020 REG /.../config.txt
   2 REG /.../leak.log

Lần chạy đầu không có -XX:-MaxFDLimit, chương trình mở hơn 61.000 reader mới hỏng, vì JVM đã nâng soft limit lên hard limit như mục 5. Trên Linux dùng thêm ls -l /proc/<pid>/fd và cat /proc/<pid>/limits.

Cách sửa: try (BufferedReader r = Files.newBufferedReader(p)) { return r.readLine(); } và cảnh báo trên metric số fd. Ngoài đời, reader không đóng thường nằm chờ GC (JDK đóng fd qua Cleaner khi thu hồi), nên số fd lên xuống theo chu kỳ GC; đừng dựa vào GC để đóng tài nguyên.

Ghi nhớ

  • Giải thích được hai pha của một lần đọc mạng và mô hình I/O nào chặn pha nào.
  • Giải thích được vì sao epoll scale tốt hơn select/poll, và vì sao file thường không dùng được epoll.
  • Biết request thứ 201 và kết nối thứ 9.000 của Tomcat gặp gì, và virtual thread dời trần đi đâu.
  • Biết write() thành công chưa phải là bền, và ba cách đánh đổi giữa fsync và throughput.
  • Biết phân biệt limit fd thấp với rò rỉ fd, và đo bằng gì.

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

Junior

Đọc RAM có phải là I/O không? DMA là gì?

Không: RAM được CPU truy cập trực tiếp, còn I/O là trao đổi với bên ngoài qua kernel và driver.

I/O là trao đổi với đĩa, mạng, ngoại vi. DMA cho thiết bị tự chép dữ liệu vào RAM không cần CPU, xong thì báo bằng interrupt.

File descriptor là gì? “Too many open files” nghĩa là gì?

fd là số nguyên kernel trả về khi process mở file, socket, pipe hay thiết bị; lỗi nghĩa là process đã chạm giới hạn số fd.

Giới hạn đặt bằng ulimit -n hoặc LimitNOFILE. Chạm nó do limit thấp hoặc do rò fd. Số fd tăng mãi theo thời gian là rò rỉ.

Vì sao phải bọc FileInputStream bằng BufferedInputStream?

Vì FileInputStream.read() không có buffer, mỗi lần gọi là một system call.

Đọc 20 MB từng byte mất vài giây, có buffer 64 KB còn khoảng 100 ms. Kèm try-with-resources để chắc chắn đóng stream.

Mid

Phân biệt blocking, non-blocking, multiplexing và asynchronous I/O.

Khác nhau ở chỗ thread bị chặn ở pha nào: chờ dữ liệu, hay chép từ kernel sang user.

Blocking chặn cả hai. Non-blocking trả EAGAIN nếu chưa có dữ liệu. Multiplexing cho một thread chờ nhiều fd. Asynchronous (io_uring, IOCP) không chặn pha nào. Ba cái đầu vẫn synchronous vì thread đứng chờ lúc chép.

Vì sao epoll scale tốt hơn select và poll?

Vì epoll đăng ký fd một lần và epoll_wait chỉ tốn theo số fd sẵn sàng, còn select/poll duyệt cả N fd mỗi lần.

select/poll nhận cả tập fd mỗi lần, kernel và ứng dụng đều duyệt N fd: O(N), select còn giới hạn 1.024. epoll đăng ký bằng epoll_ctl (cây đỏ đen), kernel đưa fd vào ready list bằng callback khi có dữ liệu.

Server lắng nghe port 8080 có bị giới hạn 65.535 kết nối không?

Không. Kết nối định danh bằng bộ bốn IP/port nguồn và đích, nên giới hạn thật là fd, bộ nhớ và mô hình thread.

Giới hạn port chỉ ảnh hưởng phía gọi ra cùng một đích (~28.000 port nguồn, TIME_WAIT 60 giây), nên cần connection pool và keep-alive.

Senior

Tomcat mặc định 200 thread. Request thứ 201 và kết nối thứ 9.000 gặp chuyện gì?

Request thứ 201 được nhận nhưng chờ worker rảnh; kết nối thứ 9.000 vượt max-connections (8.192) nên nằm trong backlog, đầy nữa thì bị từ chối.

NIO connector tách giữ kết nối khỏi xử lý: Poller giữ tới 8.192 kết nối, worker pool (200) chạy servlet. Quá 8.192 kết nối thì kết nối mới nằm trong backlog accept-count (100), đầy nữa thì client timeout hoặc bị từ chối. Virtual thread bỏ trần 200 nhưng trần dời sang connection pool, cần timeout ở đó.

Virtual thread chạy code blocking trên epoll như thế nào?

JDK biến lệnh đọc chặn thành: đăng ký fd với epoll, park virtual thread, unpark khi socket sẵn sàng.

Khi virtual thread đọc socket chưa có dữ liệu, JDK chuyển socket sang non-blocking, đăng ký fd với poller nội bộ (epoll trên Linux), park virtual thread và tháo nó khỏi carrier. Epoll báo sẵn sàng thì poller unpark, virtual thread chạy tiếp trên carrier bất kỳ, stack nằm trong heap. Ngoại lệ: file I/O chiếm carrier (scheduler bù bằng carrier tạm), và ở Java 21 I/O trong synchronized gây pinning (sửa ở Java 24).

write() trả về thành công rồi máy mất điện. Dữ liệu còn không?

Có thể không: write() chỉ chép vào page cache, kernel flush sau.

Muốn bền phải fsync (FileChannel.force(true)). Database fsync mỗi commit kèm group commit, hoặc nới ra mỗi giây và chấp nhận mất tối đa một giây; Kafka dựa vào replication.

Service báo “Too many open files” lúc 3 giờ sáng. Điều tra thế nào?

Xem limit và số fd hiện tại, rồi nhìn lịch sử metric để phân biệt limit thấp với rò rỉ, sau đó tìm nguồn bằng lsof.

  • Xem limit (cat /proc/<pid>/limits) và số fd đang mở (ls /proc/<pid>/fd | wc -l).
  • Lịch sử metric số fd: tăng theo tải rồi giảm là limit thấp, tăng đều không giảm là rò rỉ.
  • Nhóm fd bằng lsof -p <pid> và ss -tanp: nhiều file cùng đường dẫn là stream không đóng; nhiều socket CLOSE_WAIT tới một host là response body không đóng.
  • Sửa gốc trong code, thêm cảnh báo khi fd vượt 80% limit.

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
system call /ˈsɪstəm kɔːl/ lời gọi vào kernel “Every unbuffered read() is a system call, so reading byte by byte is painfully slow.”
file descriptor /faɪl dɪˈskrɪptə/ số định danh file/socket đã mở “Each socket consumes a file descriptor, so the fd limit caps open connections.”
non-blocking /nɒn ˈblɒkɪŋ/ không chặn, trả về ngay “A non-blocking read returns EAGAIN when no data is available yet.”
I/O multiplexing /ˈmʌltɪplɛksɪŋ/ một thread chờ nhiều fd “I/O multiplexing lets one thread watch tens of thousands of sockets.”
event loop /ɪˈvɛnt luːp/ vòng lặp xử lý sự kiện “Never block the event loop, or every connection on it stalls.”
edge-triggered /ɛdʒ ˈtrɪɡəd/ chỉ báo khi trạng thái đổi “With edge-triggered epoll you must drain the socket until EAGAIN.”
back-pressure /bæk ˈprɛʃə/ chặn bớt khi quá tải “The connection pool acts as back-pressure for virtual threads.”
page cache /peɪdʒ kæʃ/ cache file trong RAM của kernel “A successful write() only means the data reached the page cache.”
durability /ˌdjʊərəˈbɪləti/ tính bền dữ liệu “Durability needs an fsync, or replication to independent machines.”
ephemeral port /ɪˈfɛmərəl pɔːt/ port nguồn tạm phía client “Ephemeral port exhaustion hits the client side, not the server.”

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.