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
Pod Java bị OOMKilled dù heap mới dùng một nửa; free -m báo còn 200 MB “free” mà không ai lo; hai thread tăng hai biến khác nhau lại chậm gấp ba. Cả ba đến từ cách OS và CPU quản lý bộ nhớ. Đọc xong, bạn giải thích được từng cái, kèm cách tính memory limit cho một service Java. Nên đọc trước phần 1 (process, kernel mode).
1. Bộ nhớ ảo
Ý chính: mỗi process thấy một không gian địa chỉ riêng như thể có cả bộ nhớ cho mình. MMU (bộ dịch địa chỉ nằm trong CPU) đổi địa chỉ ảo sang địa chỉ vật lý ở mỗi lần truy cập, dựa trên bảng trang do kernel lập.
Không có bộ nhớ ảo, process A ghi x = 1 vào ô 0x2000, process B ghi x = 2 vào cùng ô đó, và A đọc lại thấy giá trị của B. Với bộ nhớ ảo, cùng địa chỉ 0x2000 của A và B trỏ tới hai frame (khung trang vật lý) khác nhau. Bộ nhớ chia thành trang (page), thường 4 KB.
flowchart LR
A[Process A: địa chỉ ảo 0x2000] --> PTA[Bảng trang của A]
B[Process B: địa chỉ ảo 0x2000] --> PTB[Bảng trang của B]
PTA --> F7[Frame vật lý số 7]
PTB --> F3[Frame vật lý số 3]
- Mỗi mục bảng trang có bit thuộc tính: có trong RAM không (present), được ghi không, user mode được truy cập không, được thực thi không (NX). Nhờ đó kernel chặn ghi vào vùng code, chạy code từ vùng dữ liệu, và user mode đọc vùng kernel.
- TLB (translation lookaside buffer) là cache nhỏ của CPU lưu các bản dịch gần đây, để không phải tra bảng trang mỗi lần.
- Huge page (2 MB hoặc 1 GB) giảm số mục TLB cần thiết đi 512 lần.
Bảng trang nhiều cấp, giới hạn của TLB và transparent huge pages
Trên x86-64, bảng trang có 4 cấp (5 cấp trên CPU mới), nên một lần dịch địa chỉ có thể tốn tới 4 lần đọc bộ nhớ. TLB chỉ có vài chục đến vài nghìn mục. Với trang 4 KB, 64 mục TLB chỉ phủ 256 KB; heap 8 GB truy cập ngẫu nhiên sẽ trượt TLB liên tục.
Page fault
Ý chính: bộ nhớ ảo được cấp lười. malloc hay mmap 1 GB chỉ giữ chỗ; lần đầu chạm vào một trang chưa có frame, MMU báo page fault và kernel cấp frame rồi cho chạy tiếp.
| Loại | Khi nào | Giá |
|---|---|---|
| Minor fault | không cần đĩa: cấp frame mới, hoặc trang đã có trong page cache | cỡ micro giây |
| Major fault | phải đọc đĩa: trang bị swap ra, hoặc đọc file qua mmap lần đầu | hàng chục µs (NVMe) tới hàng ms (HDD) |
Đo bằng ps -o min_flt,maj_flt -p <pid> hoặc pidstat -r. Major fault liên tục trên một service là dấu hiệu thiếu RAM.
Khởi động JVM không còn page fault trên heap
2. Khi cần nhiều hơn RAM: overcommit, swap và OOM killer
Ý chính: Linux cho xin nhiều hơn RAM có (overcommit), vì phần lớn bộ nhớ xin về chưa bao giờ được chạm. Khi RAM thật cạn, kernel bỏ page cache, đẩy trang ra swap, và cuối cùng OOM killer giết một process.
Slide viết “bộ nhớ ảo = bộ nhớ vật lý + swap”. Câu này dễ gây hiểu nhầm.
vm.overcommit_memory: 0 là đoán theo heuristic (mặc định), 1 là luôn đồng ý, 2 là nghiêm ngặt. Khi RAM cạn, kernel thu hồi theo thứ tự đại khái:
- Bỏ các trang page cache chưa bị sửa (đọc lại từ đĩa được), ghi các trang đã sửa (dirty) về đĩa.
- Đẩy trang anonymous (heap, stack, không có file đứng sau) ra swap nếu có.
vm.swappiness(mặc định 60) chỉnh ưu tiên giữa bước 1 và bước 2. - Vẫn không đủ thì OOM killer chọn process có
oom_scorecao nhất (gần như là process dùng nhiều RAM nhất) và kill bằng SIGKILL.
Trong container, giới hạn là memory.max của cgroup (nhóm process kernel giới hạn tài nguyên chung; resources.limits.memory của Kubernetes). Vượt giới hạn thì OOM killer chạy trong cgroup đó, pod có trạng thái OOMKilled và exit code 137.
java.lang.OutOfMemoryError: Java heap space |
Container OOMKilled (exit 137) |
|
|---|---|---|
| Ai phát hiện | JVM: heap đầy sau GC | Kernel: RSS của cgroup vượt memory.max |
| Có stack trace, heap dump không | có (-XX:+HeapDumpOnOutOfMemoryError) |
không: SIGKILL, JVM không kịp làm gì |
| Nguyên nhân thường gặp | leak trên heap, -Xmx nhỏ |
heap cộng bộ nhớ ngoài heap vượt limit |
| Cách xử lý | phân tích heap dump | giảm heap so với limit, đo bằng NMT |
3. JVM trong container: heap chỉ là một phần
Ý chính: RSS của JVM là heap cộng nhiều vùng ngoài heap, thường vài trăm MB. Mặc định JVM lấy 25% memory limit làm heap tối đa; muốn đặt đúng thì đo bằng Native Memory Tracking (NMT).
- Heap (
-Xmx). - Metaspace: metadata của class. Spring Boot lớn có thể dùng 100–200 MB.
- Code cache: code đã được JIT biên dịch, tối đa 240 MB mặc định.
- Thread stack: mỗi thread giữ chỗ 1 MB ảo, thường dùng thật vài trăm KB.
- Direct buffer (
ByteBuffer.allocateDirect, Netty, client Kafka) và vùng mmap. - Cấu trúc của GC (remembered set, card table của G1: vài phần trăm heap) và bộ nhớ
malloc(glibc arena, thư viện native).
Kiểm chứng 25% (MaxRAMPercentage=25) trong container -m 512m (JDK 21):
$ java -XX:+PrintFlagsFinal -version | grep MaxHeapSize
size_t MaxHeapSize = 134217728 # 128 MB = 25% của 512 MB
$ java -XX:MaxRAMPercentage=75 -XX:+PrintFlagsFinal -version | grep MaxHeapSize
size_t MaxHeapSize = 402653184 # 384 MB
Đặt cờ này vào image ở đâu, cùng Dockerfile nhiều stage và cách đọc OOMKilled, có ở Docker cho Spring Boot.
Kết quả NMT dưới đây: heap mới commit 8 MB mà RSS đã 152 MB. Thứ đáng xem là committed và RSS; reserved (chỉ giữ chỗ địa chỉ) gần 2 GB không liên quan tới memory limit.
Thí nghiệm NMT: 64 MB direct buffer và 200 thread trong container 512 MB
Chương trình thử có heap tối đa 128 MB, cấp 64 MB direct buffer và 200 thread đang ngủ, chạy trong container -m 512m:
$ java -Xmx128m -XX:NativeMemoryTracking=summary NativeMem &
maxHeap=123 MB, heapCommitted=7 MB
VmRSS: 155644 kB
Threads: 213
$ jcmd <pid> VM.native_memory summary scale=MB
Total: reserved=1967MB, committed=118MB
- Java Heap (reserved=128MB, committed=8MB)
- Class (reserved=1024MB, committed=0MB)
- Thread (reserved=425MB, committed=22MB)
- Code (reserved=242MB, committed=7MB)
- Other (reserved=64MB, committed=64MB)
- Metaspace (reserved=64MB, committed=1MB)
“Other” 64 MB là direct buffer. 213 thread giữ chỗ 425 MB nhưng chỉ commit 22 MB.
4. Page cache và mmap
Ý chính: kernel giữ nội dung file vừa đọc, vừa ghi trong RAM (page cache) để lần sau không chạm đĩa. Vì vậy RAM “trống” trên Linux gần như luôn bị page cache dùng, và đó là điều tốt.
- Đọc: kernel đọc từ đĩa vào page cache, rồi sao chép sang buffer của ứng dụng. Lần sau trang còn trong cache thì không chạm đĩa.
- Ghi:
write()chỉ sửa trang trong page cache và đánh dấu dirty; kernel ghi xuống đĩa sau vài giây, trừ khi ứng dụng gọifsync().
$ free -m
total used free shared buff/cache available
Mem: 15890 6120 212 150 9558 9310
Cột cần nhìn là available (ước lượng bộ nhớ cấp được, gồm cả page cache bỏ được), không phải free. Máy trên còn khoảng 9 GB dùng được.
Hệ thống lưu trữ dựa hẳn vào page cache:
- PostgreSQL đặt
shared_bufferskhoảng 25% RAM, để phần còn lại cho page cache của OS (effective_cache_sizebáo cho planner biết điều đó). - Kafka ghi log tuần tự vào page cache và để consumer đọc lại từ đó, gần như không chạm đĩa khi consumer theo kịp (xem Vì sao Kafka nhanh và bền). Hệ quả: đừng cho JVM của broker Kafka heap quá lớn; RAM để cho page cache có giá trị hơn.
mmap ánh xạ thẳng một file vào không gian địa chỉ của process: đọc mảng byte trong bộ nhớ chính là đọc page cache của file, không cần syscall read và không sao chép. Java có FileChannel.map() trả MappedByteBuffer.
mmap trong Kafka, Lucene và cái giá phải trả
Kafka mmap file index; Lucene (Elasticsearch, OpenSearch) mmap các segment, nên Elasticsearch yêu cầu vm.max_map_count ít nhất 262144.
Đổi lại, lỗi I/O trên vùng mmap hiện ra dưới dạng SIGBUS thay vì IOException, và trang bị đẩy khỏi cache gây major fault ngay trong thread đang xử lý request.
5. Cache của CPU và memory model
Ý chính: RAM chậm hơn L1 khoảng 100 lần, nên CPU nạp theo cache line 64 byte và giữ bản sao ở từng core. Thread khác có thể chưa thấy giá trị mới; Java Memory Model quy định khi nào chắc chắn thấy.
Slide về “memory model” nói về tầng cache giữa CPU và RAM: L1, L2 riêng từng core, L3 dùng chung.
Cache line là 64 byte trên x86 và đa số ARM server (chip Apple M báo 128 byte). Vì vậy duyệt mảng tuần tự rất nhanh: một lần nạp được 8 phần tử long, và bộ prefetch đoán được bước tiếp. Duyệt LinkedList hay cây object rải rác thì mỗi bước là một cache miss.
Phần cứng giữ các bản sao nhất quán bằng cache coherence, theo từng cache line.
Bảng độ trễ các tầng bộ nhớ, cache coherence và store buffer
| Tầng | Kích thước thường gặp | Độ trễ xấp xỉ |
|---|---|---|
| Thanh ghi | vài chục giá trị | dưới 1 ns |
| L1 (riêng mỗi core) | 32–128 KB | ~1 ns |
| L2 (riêng mỗi core hoặc cụm core) | 256 KB – vài MB | ~3–5 ns |
| L3 (chung) | vài MB – vài chục MB | ~10–20 ns |
| RAM | GB | ~80–100 ns |
| Đọc 4 KB ngẫu nhiên từ SSD NVMe | ~20–100 µs |
Khi nhiều core giữ bản sao của cùng một cache line, chúng có thể thấy giá trị khác nhau (đúng như slide nói). Giao thức coherence (MESI và các biến thể) xử lý việc này: trước khi một core ghi vào line, bản sao ở core khác bị đánh dấu không hợp lệ.
Nhưng để chạy nhanh, mỗi core còn có store buffer (hàng chờ ghi trước khi vào cache), và cả CPU lẫn JIT đều được phép đổi thứ tự lệnh. Vì thế một thread có thể chưa thấy giá trị thread khác vừa ghi.
Java Memory Model quy định khi nào việc ghi của thread này chắc chắn được thread khác thấy: volatile, synchronized, final và các lớp trong java.util.concurrent chèn memory barrier (lệnh cấm đổi thứ tự qua nó) để tạo quan hệ happens-before (xem race condition, volatile và deadlock).
False sharing
Ý chính: coherence hoạt động theo cache line, không theo biến. Hai thread ghi hai biến khác nhau nằm chung một line liên tục làm mất hiệu lực line của nhau, chậm như tranh chấp một biến chung.
Giống hai người viết hai câu khác nhau trên cùng một tờ giấy: mỗi lần ai viết, người kia phải đưa tờ giấy sang. Cách chữa: tách hai biến ra các line khác nhau bằng padding, hoặc dùng @Contended.
LongAdder và @Contended trong JDK
Bài tập
Bài 1: Tính memory limit cho một service Spring Boot
Đề. Một service Spring Boot (Tomcat, Hibernate, client Kafka) chạy tải thật cho thấy: dữ liệu sống trên heap sau full GC khoảng 400 MB; metaspace 160 MB; khoảng 250 thread; client Kafka và Netty của WebClient dùng tổng cộng khoảng 100 MB direct memory. Đặt -Xmx và memory limit của container, giải thích.
Lời giải Bài 1: cộng từng phần, ra limit 2 GiB
| Phần | Ước lượng | Lý do |
|---|---|---|
| Heap | 1.024 MB | khoảng 2,5 lần dữ liệu sống để GC không chạy liên tục |
| Metaspace | 160 MB | đo được |
| Code cache | 80 MB | thường 50–100 MB sau khi nóng |
| Thread stack | 125 MB | 250 thread × khoảng 0,5 MB commit |
| Direct buffer | 100 MB | đo được, chặn trên bằng -XX:MaxDirectMemorySize=128m |
| Cấu trúc GC (G1) | 60 MB | vài phần trăm của heap |
| malloc, thư viện native, khác | 100 MB | dư cho glibc arena, zip, SSL |
| Tổng | khoảng 1,65 GB |
Cộng khoảng 20% dư: limit 2 GiB, -Xmx1g (hoặc MaxRAMPercentage=50), request bằng limit. Kiểm chứng bằng load test, so NMT với working set của pod. Nếu working set tăng mãi trong khi heap ổn định, nghi leak ngoài heap (direct buffer, số thread tăng dần, glibc arena; thử MALLOC_ARENA_MAX=2). Rò rỉ ngoài heap thường chỉ lộ ra sau vài giờ, nên cần soak test như trong Performance test.
Bài 2: Đo false sharing
Đề. Viết chương trình cho hai thread, mỗi thread tăng biến volatile long của riêng mình 200 triệu lần. So sánh khi hai biến nằm sát nhau và khi được chèn padding 56 byte ở giữa.
Trên máy thật (Apple M4) padding nhanh gấp khoảng 3 lần; trong máy ảo 2 vCPU gần như không khác.
Lời giải Bài 2: code, số đo trên Apple M4 và máy ảo 2 vCPU
public class FalseSharing {
static final long ITER = 200_000_000L;
static final class Packed { // a và b nằm sát nhau: cùng cache line
volatile long a;
volatile long b;
}
static final class Padded { // 7 long (56 byte) đẩy b sang line khác
volatile long a;
long p1, p2, p3, p4, p5, p6, p7;
volatile long b;
}
public static void main(String[] args) throws Exception {
for (int round = 0; round < 5; round++) {
Packed packed = new Packed();
long t1 = run(() -> { for (long i = 0; i < ITER; i++) packed.a++; },
() -> { for (long i = 0; i < ITER; i++) packed.b++; });
Padded padded = new Padded();
long t2 = run(() -> { for (long i = 0; i < ITER; i++) padded.a++; },
() -> { for (long i = 0; i < ITER; i++) padded.b++; });
System.out.printf("round %d: same line %5d ms | padded %5d ms%n", round, t1, t2);
}
}
static long run(Runnable r1, Runnable r2) throws InterruptedException {
Thread a = new Thread(r1), b = new Thread(r2);
long t0 = System.nanoTime();
a.start(); b.start(); a.join(); b.join();
return (System.nanoTime() - t0) / 1_000_000;
}
}
Kết quả (JDK 21):
# macOS, Apple M4, 10 core
round 0: same line 1232 ms | padded 367 ms
round 4: same line 1048 ms | padded 366 ms
# Linux container trên máy ảo 2 vCPU
round 0: same line 928 ms | padded 1056 ms
round 2: same line 753 ms | padded 696 ms
round 4: same line 716 ms | padded 728 ms
Giải thích.
- Máy thật: padding nhanh gấp khoảng 3 lần vì hai core không còn giành nhau một cache line.
- Máy ảo 2 vCPU: gần như không khác. Nhiều khả năng hai vCPU không được giữ trên hai core vật lý riêng, hoặc hypervisor xếp chúng xen kẽ trên cùng một core, nên không có hai core thật cùng ghi.
- Lưu ý: JVM được phép sắp xếp lại field, nên padding bằng field không được đảm bảo (
@Contendedmới là cách chính thức). Apple M4 báo cache line 128 byte nên pad 128 byte mới chắc chắn. Đây là benchmark tay, không có JMH, chỉ tin vào bậc độ lớn. - Bài học: false sharing chỉ đáng lo ở biến bị nhiều thread ghi rất dày (bộ đếm, chỉ số hàng đợi); với code nghiệp vụ thông thường thì không.
Ghi nhớ
- Giải thích được MMU, bảng trang, TLB làm gì, và minor fault khác major fault ở đâu.
- Giải thích được vì sao VSZ lớn không đáng lo, và thứ tự kernel thu hồi bộ nhớ trước khi OOM killer ra tay.
- Phân biệt được
OutOfMemoryErrorvớiOOMKilled, và vì sao JVM không nên dùng swap. - Liệt kê được các phần của RSS ngoài heap và tính được memory limit cho một service Java.
- Giải thích được false sharing và vì sao có cache coherence vẫn cần
volatile.
Câu hỏi phỏng vấn
Junior
Bộ nhớ ảo là gì và giải quyết vấn đề gì?
Mỗi process thấy một không gian địa chỉ ảo riêng; MMU trong CPU dịch sang địa chỉ vật lý qua bảng trang do kernel quản lý.
Nó giải quyết việc các process ghi đè bộ nhớ của nhau, cho phép đặt quyền đọc, ghi, thực thi theo từng trang, và cho phép cấp bộ nhớ lười, chia sẻ trang (thư viện, copy-on-write), ánh xạ file vào bộ nhớ.
free trên Linux báo còn rất ít bộ nhớ free. Có đáng lo không?
Thường là không: Linux dùng RAM trống làm page cache và bỏ nó khi process cần. Nhìn cột available, không phải free.
Chỉ đáng lo khi available thấp, swap in/out liên tục (si, so trong vmstat) hoặc major fault tăng.
Page fault là gì? Minor và major khác nhau thế nào?
Page fault xảy ra khi process truy cập một trang ảo chưa có frame vật lý hoặc không được phép truy cập. Minor không cần đĩa, major phải đọc đĩa.
Minor fault: cấp trang mới, hoặc trang đã có trong page cache, tốn micro giây. Major fault: trang bị swap, file mmap chưa nạp, tốn từ chục µs tới ms. Major fault liên tục là dấu hiệu thiếu RAM.
Mid
Vì sao RSS của JVM lớn hơn -Xmx?
Heap chỉ là một phần; một service Spring Boot thường có 300–600 MB ngoài heap.
JVM còn metaspace, code cache, stack của mỗi thread, direct buffer và vùng mmap, cấu trúc của GC, và bộ nhớ malloc của thư viện native. Đo bằng -XX:NativeMemoryTracking=summary và jcmd <pid> VM.native_memory summary.
OutOfMemoryError và pod bị OOMKilled khác nhau thế nào?
OutOfMemoryError là JVM báo heap đầy; OOMKilled là kernel kill process vì RSS của cgroup vượt limit.
OutOfMemoryError: Java heap space có stack trace và có thể có heap dump. OOMKilled (exit 137) là SIGKILL nên không có log hay dump. Cách sửa thứ nhất là tìm leak trên heap; thứ hai là giảm heap so với limit hoặc tìm phần ngoài heap đang lớn.
Vì sao không nên để JVM dùng swap?
GC phải duyệt phần lớn heap; phần heap nằm trong swap biến mỗi chu kỳ GC thành hàng loạt major fault, pause từ vài chục ms thành vài giây.
Nên tắt swap hoặc đặt vm.swappiness rất thấp, và giới hạn heap để cả process vừa RAM.
Vì sao PostgreSQL và Kafka không dùng hết RAM cho cache của chính mình?
Vì chúng dựa vào page cache của OS: nó sống sót qua khi process khởi động lại, không gây áp lực GC, và kernel tự quản lý thu hồi.
PostgreSQL đặt shared_buffers khoảng 25% RAM và để phần còn lại cho page cache; Kafka ghi và đọc log qua page cache, và gửi dữ liệu cho consumer bằng zero-copy từ page cache.
Senior
Bạn tính memory limit cho một service Java chạy trên Kubernetes thế nào?
Đo chứ không đoán: heap theo dữ liệu sống, phần ngoài heap theo NMT, cộng lại và thêm 20–30% dư.
Chạy tải thật, lấy dữ liệu sống sau full GC để chọn heap (khoảng 2–3 lần), đo phần ngoài heap bằng NMT (metaspace, code cache, thread, direct buffer, GC). Đặt -Xmx hoặc MaxRAMPercentage tương ứng, giới hạn MaxDirectMemorySize, bật ExitOnOutOfMemoryError, request bằng limit. Theo dõi working set, không phải usage (usage gồm cả page cache).
False sharing là gì, khi nào đáng quan tâm?
Hai thread ghi hai biến khác nhau trên cùng một cache line làm mất hiệu lực line của nhau liên tục; chỉ đáng lo với biến bị nhiều thread ghi rất dày.
Cache coherence hoạt động theo cache line (64 byte, hoặc 128 trên một số chip ARM), nên nó chậm như tranh chấp thật; thí nghiệm trên Apple M4 chậm gấp khoảng 3 lần. Ví dụ đáng lo: bộ đếm, con trỏ của ring buffer. Cách chữa: padding, @Contended, hoặc dùng sẵn LongAdder.
Cache coherence của CPU đã giữ nhất quán, sao Java vẫn cần volatile?
Coherence chỉ đảm bảo các core đồng ý về một cache line khi giá trị đã tới cache; volatile mới tạo happens-before.
Trước khi tới cache, giá trị có thể nằm trong store buffer của core, trong thanh ghi, hoặc bị JIT và CPU đổi thứ tự. volatile và các cơ chế đồng bộ chèn memory barrier và cấm JIT tối ưu bỏ lần đọc, tạo quan hệ happens-before mà Java Memory Model định nghĩa, nên đúng trên mọi kiến trúc CPU, kể cả ARM với memory model yếu hơn x86.
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 |
|---|---|---|---|
| virtual memory | /ˈvɜːtʃuəl ˈmeməri/ | bộ nhớ ảo | “Virtual memory gives every process its own address space.” |
| page table | /peɪdʒ ˈteɪbl/ | bảng ánh xạ trang ảo sang frame | “The MMU walks the page table on a TLB miss.” |
| TLB | /ˌtiː el ˈbiː/ | cache bản dịch địa chỉ | “Huge pages cut TLB misses on a large heap.” |
| page fault | /peɪdʒ fɔːlt/ | truy cập trang chưa có frame | “Major page faults during GC are a sign the heap was swapped out.” |
| resident set size | /ˈrezɪdənt set saɪz/ | bộ nhớ thật process đang dùng | “RSS is what the container limit cares about, not virtual size.” |
| OOM killer | /ˌəʊ əʊ ˈem ˈkɪlə/ | cơ chế kernel kill process khi hết RAM | “Exit code 137 means the OOM killer or a SIGKILL.” |
| page cache | /peɪdʒ kæʃ/ | RAM chứa nội dung file | “Kafka consumers that keep up read straight from the page cache.” |
| working set | /ˈwɜːkɪŋ set/ | bộ nhớ đang thật sự cần | “I alert on working set, not on usage, because usage includes page cache.” |
| cache line | /kæʃ laɪn/ | đơn vị 64 byte CPU nạp vào cache | “Coherence works per cache line, not per variable.” |
| false sharing | /fɔːls ˈʃeərɪŋ/ | hai biến khác nhau chung một cache line | “Padding fixed a false sharing problem in our counters.” |
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.