Đến nội dung chính
Sổ ôn Backend

Tìm kiếm

Java CoreSenior24 phút đọc

Garbage collector trong JVM: G1, ZGC, đọc GC log và chẩn đoán OutOfMemoryError

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

Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.

Garbage collector trong JVM: G1, ZGC, đọc GC log và chẩn đoán OutOfMemoryError

1Cái gì là rác

JVM không đếm tham chiếu. Nó đi từ GC root theo mọi tham chiếu; object không chạm tới được là rác, kể cả khi chúng trỏ lẫn nhau.

  • Biến cục bộ, tham số của thread đang chạy
  • Field static của class đã nạp
  • Thread đang sống, monitor đang bị giữ
  • Tham chiếu từ code native (JNI)

2Heap theo thế hệ

Hầu hết object chết trẻ, nên heap chia young và old. Dọn young rẻ vì chi phí tỉ lệ với số object còn sống, không phải số rác.

Vùng Chuyện gì xảy ra
Eden new cấp phát nhanh qua TLAB
Survivor Minor GC chép object sống, tuổi +1
Old Đủ tuổi (tối đa 15) thì lên đây
Old đầy Mixed GC; không kịp thì Full GC

3Chọn collector

Mọi collector đều mark rồi dọn; khác nhau ở chỗ làm khi app dừng (stop-the-world) hay song song với app. Chọn theo mục tiêu, quyết định bằng load test.

Collector Pause Hợp với
Parallel Trung bình, theo heap Batch, cần throughput
G1 (mặc định) Nhắm ~200 ms Đa số web service
ZGC Dưới 1 ms Heap lớn, SLO chặt

4Cấu hình và GC log

Cấu hình quan trọng nhất là kích thước heap, rồi tới collector và pause mục tiêu. Đọc log: heap sau GC tăng mãi qua nhiều giờ là dấu hiệu leak.

java -Xms2g -Xmx2g -XX:+UseG1GC \
  -XX:MaxGCPauseMillis=200 \
  -Xlog:gc*:file=/var/log/app/gc.log \
  -XX:+HeapDumpOnOutOfMemoryError \
  -XX:+ExitOnOutOfMemoryError -jar app.jar

5Các loại OutOfMemoryError

Dòng chữ sau dấu hai chấm cho biết vùng nào cạn; có sáu loại. OOMKilled (exit 137) là kernel giết process vì tổng RSS vượt limit, không phải OOM của Java.

  • Java heap space: leak hoặc nạp quá nhiều, đọc heap dump
  • Metaspace: sinh class động, ClassLoader leak khi redeploy
  • direct buffer memory: Netty, NIO giữ buffer native
  • unable to create native thread: pool thread không giới hạn

6Tìm memory leak trên production

Xác nhận bằng số, chụp heap dump, mở bằng Eclipse MAT, xem object có retained size lớn nhất và đường tới GC root.

flowchart TD
  A["Old sau GC tăng mãi"] --> B["GC.class_histogram hai lần"]
  B --> C["jcmd GC.heap_dump"]
  C --> D["MAT: Dominator Tree"]
  D --> E["Path to GC Roots"]
  E --> F["Sửa code, soak test"]

💡 Ghi nhớ

  • Leak Java là còn giữ tham chiếu không cần nữa.

  • G1 cân bằng, ZGC pause dưới 1 ms nhưng tốn CPU hơn.

  • Pause Serial/Parallel/G1 tăng theo dữ liệu sống, ZGC thì không.

  • Luôn bật -XX:+HeapDumpOnOutOfMemoryError.

⭐ Điểm phỏng vấn

Tự trả lời trước, rồi bấm từng câu để xem đáp án.

  • GC biết object nào là rác?

    Đi từ GC root, không đếm tham chiếu.

  • G1 khác ZGC thế nào?

    G1 dừng để chép, ZGC dời song song.

  • Heap trống mà vẫn OOM?

    Metaspace, direct buffer, native thread, mảng quá lớn.

⚠️ Lỗi thường gặp

  • Tăng -Xmx để "chữa" leak: app chỉ chết chậm hơn.

  • Gọi System.gc() hay đặt cứng -Xmn cho G1.

  • Nhầm OOMKilled của container với OutOfMemoryError của JVM.

“G1 khác ZGC thế nào, khi nào dùng cái nào” và “heap còn trống mà app vẫn OOM là sao” là hai câu senior hay bị hỏi nhất về JVM. Bài này giải thích GC từ gốc (cái gì là rác), so các collector bằng số đo thật, rồi đi qua từng loại OutOfMemoryError và cách tìm nguyên nhân trên production. Nên đọc trước các vùng nhớ của JVM.

Sơ đồ tóm tắt:

flowchart LR
  NEW["new Object()"] --> EDEN["Eden"]
  EDEN -->|"Minor GC: còn sống"| SUR["Survivor (tuổi +1)"]
  SUR -->|"đủ tuổi / hết chỗ"| OLD["Old"]
  EDEN -->|"chết trẻ: bỏ"| FREE["Giải phóng"]
  OLD -->|"Mixed/Major GC"| FREE
  OLD -->|"đầy, GC không cứu được"| OOM["OutOfMemoryError"]
  OOM --> DUMP["Heap dump → MAT"]

1. Cái gì là rác: reachability và GC root

Ý chính: JVM không đếm tham chiếu; nó đi từ các GC root theo mọi tham chiếu và đánh dấu những gì chạm được. Object không được đánh dấu là rác, dù chúng trỏ lẫn nhau.

GC root gồm:

  • Biến cục bộ và tham số trong frame của mọi thread đang chạy.
  • Field static của các class đã nạp (qua object Class và ClassLoader của nó).
  • Thread đang sống, monitor đang bị giữ (synchronized).
  • Tham chiếu từ code native (JNI global ref).

Hệ quả: “memory leak” trong Java không phải quên free, mà là còn giữ tham chiếu không cần nữa. Nguồn hay gặp: static Map làm cache không giới hạn, listener đăng ký mà không gỡ, ThreadLocal không remove() trên thread của pool, collection trong singleton chỉ thêm không xoá.

Soft, weak, phantom reference dùng khi nào

2. Heap theo thế hệ

Ý chính: hầu hết object chết rất trẻ (request xong là bỏ), số ít sống rất lâu (cache, bean). Vì vậy heap chia young (Eden + 2 Survivor) và old: dọn young thường xuyên và rẻ, vì chi phí tỉ lệ với số object còn sống, không phải số rác.

  • Cấp phát: mỗi thread có TLAB (thread-local allocation buffer, một mẩu Eden riêng), nên new chỉ là tăng một con trỏ, không cần lock.
  • Minor GC: Eden đầy thì dừng app một chút, chép object còn sống sang Survivor trống, tuổi +1; Eden và Survivor cũ trở thành trống hoàn toàn (không phân mảnh).
  • Promotion: object sống qua đủ số lần (tối đa MaxTenuringThreshold, mặc định 15) hoặc Survivor hết chỗ thì lên Old.
  • Old đầy: G1 chạy mixed GC (dọn young cùng một phần old); nếu không kịp thì Full GC dừng toàn bộ, chậm nhất.

3. Các collector: Serial, Parallel, G1, ZGC, Shenandoah

Ý chính: mọi collector đều phải đánh dấu (mark) object sống rồi giải phóng chỗ của rác bằng cách quét (sweep), dồn (compact) hoặc chép (copy). Khác nhau ở chỗ làm việc đó khi app dừng (stop-the-world, STW) hay song song với app (concurrent).

Collector Ý tưởng Pause Hợp với
Serial (-XX:+UseSerialGC) một thread GC, dừng hết dài khi heap lớn container 1 CPU, heap vài trăm MB, tool, CLI
Parallel (-XX:+UseParallelGC) nhiều thread GC, vẫn dừng hết trung bình, tỉ lệ heap batch, ETL: tối đa throughput, chịu pause
G1 (-XX:+UseG1GC, mặc định) heap chia region; mark old song song; chép region nhiều rác nhất trước mục tiêu MaxGCPauseMillis=200 đa số web service, heap vài GB tới vài chục GB
ZGC (-XX:+UseZGC) mark, chép, dời object song song nhờ load barrier và colored pointer dưới 1 ms, gần như không phụ thuộc heap API nhạy latency, heap lớn (tới 16 TB)
Shenandoah (-XX:+UseShenandoahGC) dời object song song (Red Hat), có trong nhiều bản OpenJDK, không có trong Oracle JDK rất ngắn giống ZGC

CMS (Concurrent Mark Sweep) bị deprecated ở JDK 9 và xoá ở JDK 14. JVM tự chọn Serial thay vì G1 khi máy (hoặc container) có dưới 2 CPU hoặc dưới khoảng 1,8 GB RAM; kiểm tra bằng java -XX:+PrintFlagsFinal -version | grep Use.*GC.

Thí nghiệm: chương trình giữ khoảng 120 MB dữ liệu sống (cửa sổ trượt) và liên tục tạo rác, heap cố định 512 MB, JDK 25, máy 10 core, mỗi collector chạy 3 lần. maxGap là khoảng dừng lớn nhất mà thread của app cảm nhận được.

Collector Thời gian chạy maxGap Pause dài nhất trong GC log
Serial 708–827 ms 19–48 ms 35 ms
Parallel 803–890 ms 20–22 ms 19 ms
G1 797–1278 ms 33 ms 33 ms
ZGC (generational) 367–389 ms 4,8 ms 0,006 ms

Đọc số cho đúng: đây là tải tổng hợp nhỏ trên máy dư core, nên ZGC chạy nhanh nhất ở đây nhờ dùng core rảnh để GC song song; trên máy ít core hoặc CPU đã bận, ZGC sẽ tranh CPU với app và throughput thường thấp hơn G1/Parallel vài phần trăm. Pause của ZGC đo bằng micro giây, nhưng app vẫn có khoảng dừng ~5 ms do lập lịch thread và việc cấp phát chờ GC. Kết luận đáng nhớ là hình dạng: pause của Serial/Parallel/G1 tăng theo lượng dữ liệu sống, của ZGC thì không.

ZGC qua các phiên bản và vì sao nó không cần dừng để dời object
  • JDK 11: ZGC thử nghiệm. JDK 15: dùng production. JDK 21: thêm chế độ generational (-XX:+ZGenerational). JDK 23: generational là mặc định. JDK 24: bỏ hẳn chế độ không thế hệ. Tài liệu ghi “ZGC pause < 10 ms, Java 11+” là mô tả bản đầu; bản hiện nay thường dưới 1 ms.
  • Colored pointer: vài bit của mỗi tham chiếu 64-bit cho biết trạng thái (đã mark, đã dời chưa).
  • Load barrier: mỗi lần app đọc một tham chiếu từ heap, một đoạn code nhỏ kiểm tra màu; nếu object đã bị dời, barrier sửa tham chiếu sang chỗ mới ngay lúc đó. Nhờ vậy GC dời object trong khi app đang chạy.
  • Cái giá: barrier tốn vài phần trăm CPU ở mọi lần đọc tham chiếu, và GC thread chạy song song chiếm thêm core. Nếu tốc độ cấp phát vượt tốc độ dọn, thread cấp phát bị chặn (allocation stall), log ghi Allocation Stall; cách chữa là thêm heap hoặc giảm cấp phát.
  • G1 dùng write barrier (ghi nhận tham chiếu từ old sang young vào remembered set) và vẫn phải dừng app khi chép region; đó là lý do pause của G1 tăng theo dữ liệu sống trong các region được chọn.

4. Chỉnh GC: ít cờ, có số đo

Ý chính: cấu hình quan trọng nhất là kích thước heap; sau đó là chọn collector và (với G1) pause mục tiêu. Mọi thay đổi khác cần GC log chứng minh.

java -Xms2g -Xmx2g \                       # heap cố định: không mất thời gian co giãn
     -XX:+UseG1GC -XX:MaxGCPauseMillis=200 \
     -Xlog:gc*:file=/var/log/app/gc.log:time,uptime:filecount=5,filesize=20m \
     -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/dumps \
     -XX:+ExitOnOutOfMemoryError \         # chết hẳn để orchestrator khởi động lại
     -jar app.jar

Trong container, dùng -XX:MaxRAMPercentage thay cho -Xmx cứng (xem JVM trong container). Đọc một dòng log của G1:

[0.087s][info][gc] GC(1) Pause Young (Normal) (G1 Evacuation Pause) 219M->147M(512M) 30.663ms
  • Pause Young (Normal): minor GC; Pause Young (Mixed) là có dọn cả region old; Pause Full là dừng toàn bộ, đáng lo.
  • 219M->147M(512M): heap dùng trước → sau GC (tổng heap đã commit). Con số sau GC của các lần mixed/full chính là lượng dữ liệu sống; nó tăng mãi qua nhiều giờ là dấu hiệu leak.
  • 30.663ms: thời gian app bị dừng.

Bốn chỉ số nên có trên dashboard (Micrometer có sẵn jvm.gc.pause, jvm.memory.used): pause p99 và max, % thời gian CPU dành cho GC, tốc độ cấp phát (MB/s), heap old sau GC.

Những cờ và thói quen GC nên bỏ

5. Sáu loại OutOfMemoryError

Ý chính: dòng chữ sau dấu hai chấm cho biết vùng nào cạn. Đọc nó trước khi làm bất cứ gì.

Thông báo Vùng Nguyên nhân hay gặp Hướng xử lý
Java heap space heap leak (cache không giới hạn, listener, ThreadLocal); nạp quá nhiều (query không phân trang, readAllBytes file lớn); heap quá nhỏ heap dump, sửa code; chỉ tăng heap khi live set thật sự lớn
GC overhead limit exceeded heap GC chiếm >98% thời gian mà thu hồi <2% heap. Chỉ Parallel GC ném lỗi này; G1 trên JDK 21 và 25 ném thẳng Java heap space như trên
Metaspace metaspace sinh class động không giới hạn (proxy, script), ClassLoader leak khi redeploy VM.classloader_stats, tìm loader bị giữ
Cannot reserve N bytes of direct buffer memory bộ nhớ native Netty, NIO, client Kafka/gRPC giữ direct buffer; mặc định giới hạn bằng -Xmx -XX:MaxDirectMemorySize, kiểm tra buffer có được trả lại pool không
unable to create native thread OS quá nhiều thread (pool không giới hạn), ulimit -u hoặc pids.max của container giới hạn pool, dùng virtual thread cho I/O chờ, kiểm tra limit
Requested array size exceeds VM limit heap cấp phát mảng gần Integer.MAX_VALUE phần tử sửa logic tính kích thước

Bốn loại chạy thật trên JDK 21 (Oom ở Bài tập 1; Overhead chỉ là vòng lặp map.put(i, "v" + i) không dừng):

$ java -Xmx64m -XX:+HeapDumpOnOutOfMemoryError Oom heap
java.lang.OutOfMemoryError: Java heap space
Dumping heap to java_pid4182.hprof ...
$ java -XX:MaxDirectMemorySize=32m Oom direct
java.lang.OutOfMemoryError: Cannot reserve 1048576 bytes of direct buffer memory (allocated: 33554432, limit: 33554432)
$ java -XX:MaxMetaspaceSize=24m Oom meta
java.lang.OutOfMemoryError: Metaspace
$ java -Xmx32m -XX:+UseParallelGC Overhead
java.lang.OutOfMemoryError: GC overhead limit exceeded

6. Tìm memory leak trên production

Ý chính: xác nhận bằng số (old sau GC tăng mãi), chụp heap dump, mở bằng Eclipse MAT, nhìn dominator tree theo retained size, rồi lần theo đường tới GC root để biết ai đang giữ.

  1. Xác nhận: heap sau mỗi GC lớn dần qua nhiều giờ dù tải không đổi (dashboard hoặc GC log). Heap dùng nhiều nhưng sau GC trở về mức cũ thì không phải leak.
  2. Xem nhanh không dừng app: jcmd <pid> GC.class_histogram | head -20 hai lần cách nhau vài phút; class nào tăng số instance là nghi phạm.
  3. Heap dump: jcmd <pid> GC.heap_dump /dumps/app.hprof (dừng app vài giây tới vài chục giây tuỳ heap; với pod chạy nhiều bản, lấy từ một bản đã rút khỏi load balancer). Hoặc file do HeapDumpOnOutOfMemoryError để lại.
  4. Phân tích: MAT → Leak Suspects và Dominator Tree. Shallow size là kích thước của riêng object; retained size là phần sẽ được giải phóng nếu object đó mất, tức thứ cần nhìn. Chọn object lớn nhất → Path to GC Roots (bỏ weak/soft ref) để thấy chuỗi giữ nó, ví dụ static CACHE → HashMap → 2 triệu entry.
  5. Sửa và chứng minh: giới hạn cache (Caffeine với maximumSize, TTL), gỡ listener, remove() ThreadLocal trong finally; chạy soak test vài giờ xem old sau GC đi ngang.

Bài tập

Bài 1: tạo ba loại OOM và đọc chúng

Đề: viết một chương trình nhận tham số heap, direct, meta và gây ra đúng loại OutOfMemoryError tương ứng, chạy với giới hạn nhỏ (-Xmx64m, -XX:MaxDirectMemorySize=32m, -XX:MaxMetaspaceSize=24m). Với heap, bật heap dump và cho biết trong dump, object nào có retained size lớn nhất.

Lời giải Bài 1
import java.nio.ByteBuffer;
import java.util.*;

public class Oom {
    static final Map<Integer, byte[]> CACHE = new HashMap<>();   // "cache" không giới hạn

    public static void main(String[] args) throws Throwable {
        switch (args[0]) {
            case "heap" -> {
                for (int i = 0; ; i++) CACHE.put(i, new byte[1024 * 1024]);
            }
            case "direct" -> {
                List<ByteBuffer> keep = new ArrayList<>();
                while (true) keep.add(ByteBuffer.allocateDirect(1024 * 1024));
            }
            case "meta" -> {
                // nạp lại cùng một bytecode bằng loader mới mỗi vòng: mỗi lần là một class mới
                byte[] b = Oom.class.getResourceAsStream("Oom$Holder.class").readAllBytes();
                List<Object> keep = new ArrayList<>();
                while (true) {
                    ClassLoader cl = new ClassLoader(null) {
                        { keep.add(defineClass("Oom$Holder", b, 0, b.length)); }
                    };
                    keep.add(cl);
                }
            }
            default -> throw new IllegalArgumentException(args[0]);
        }
    }

    static class Holder { int a; void m() {} }
}

Kết quả (JDK 21):

$ java -Xmx64m -XX:+HeapDumpOnOutOfMemoryError Oom heap
java.lang.OutOfMemoryError: Java heap space
Dumping heap to java_pid4182.hprof ...
$ java -XX:MaxDirectMemorySize=32m Oom direct
java.lang.OutOfMemoryError: Cannot reserve 1048576 bytes of direct buffer memory (allocated: 33554432, limit: 33554432)
$ java -XX:MaxMetaspaceSize=24m Oom meta
java.lang.OutOfMemoryError: Metaspace

Trong dump (khoảng 35 MB), Dominator Tree chỉ ra Oom.CACHE (một HashMap) giữ gần toàn bộ heap; Path to GC Roots đi qua class Oom vì CACHE là field static. Bài meta cho thấy vì sao giữ reference tới loader (hay tới class nó nạp) làm metaspace không bao giờ được dọn.

Bài 2: so pause của bốn collector

Đề: viết chương trình giữ khoảng 120 MB dữ liệu sống và liên tục tạo rác; đo khoảng dừng lớn nhất mà thread app thấy. Chạy với -Xms512m -Xmx512m lần lượt -XX:+UseSerialGC, ParallelGC, G1GC, ZGC, mỗi cái 3 lần, ghi kèm -Xlog:gc. Giải thích vì sao kết quả của bạn có thể khác bảng ở mục 3.

Lời giải Bài 2
public class Churn {
    public static void main(String[] args) {
        int window = 120_000;                       // 120k mảng 1 KB còn sống
        byte[][] live = new byte[window][];
        long start = System.nanoTime(), maxGap = 0, last = start;
        for (long i = 0; i < 40_000_000L; i++) {
            byte[] garbage = new byte[64];           // rác sống rất ngắn
            garbage[0] = (byte) i;
            if (i % 8 == 0) live[(int) (i / 8 % window)] = new byte[1024];   // thay dần dữ liệu sống
            if ((i & 0xFFFF) == 0) {                 // cứ ~65k vòng đo khoảng cách thời gian một lần
                long now = System.nanoTime();
                maxGap = Math.max(maxGap, now - last);
                last = now;
            }
        }
        System.out.printf("elapsed=%d ms, maxGap=%.1f ms%n",
            (System.nanoTime() - start) / 1_000_000, maxGap / 1e6);
    }
}
for gc in UseSerialGC UseParallelGC UseG1GC UseZGC; do
  for r in 1 2 3; do java -Xms512m -Xmx512m -XX:+$gc Churn; done
done
java -Xms512m -Xmx512m -XX:+UseZGC -Xlog:gc+phases Churn | grep Pause

Mẫu log của ZGC (JDK 25) cho thấy pause đo bằng micro giây:

[0.029s][info][gc,phases] GC(0) Y: Pause Mark Start (Major) 0.006ms
[0.031s][info][gc,phases] GC(0) Y: Pause Mark End 0.006ms
[0.031s][info][gc,phases] GC(0) Y: Pause Relocate Start 0.006ms

Vì sao số có thể khác: số core (ZGC và G1 mark song song cần core rảnh), JDK (ZGC trên JDK 21 mặc định chưa generational), JIT có thể xoá cấp phát garbage nhờ escape analysis (nên phải ghi vào garbage[0]), và đo bằng vòng lặp không thay được JMH hay load test thật. Điều nên rút ra: pause của các collector dừng-để-chép tăng theo dữ liệu sống, của ZGC thì gần như không; còn throughput phải đo trên tải thật.

Ghi nhớ

  • Giải thích được GC root là gì và vì sao vòng tham chiếu không gây leak trong Java.
  • Mô tả được đường đi của object qua Eden, Survivor, Old và premature promotion.
  • So được Serial, Parallel, G1, ZGC theo pause, throughput, CPU, và biết chọn bằng số đo.
  • Đọc được một dòng GC log và nhận ra dấu hiệu leak (heap sau GC tăng mãi).
  • Kể được sáu loại OutOfMemoryError, phân biệt với OOMKilled, và quy trình heap dump → MAT.

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

GC xác định object nào là rác như thế nào? Java có dùng reference counting không?

Không; GC đi từ các GC root (biến cục bộ của thread đang chạy, field static, thread đang sống, JNI ref) theo mọi tham chiếu, object nào không chạm tới được là rác.

Vì dựa trên reachability, hai object trỏ lẫn nhau mà không ai từ root trỏ tới vẫn bị dọn, khác reference counting (Python dùng chính, cần thêm bộ dò vòng). Memory leak trong Java vì thế là “vẫn còn đường tới object không cần nữa”: static map, listener chưa gỡ, ThreadLocal trên pool thread.

Vì sao heap chia young và old? Minor GC, major GC và full GC khác nhau thế nào?

Vì hầu hết object chết trẻ; dọn riêng vùng young rẻ vì chi phí tỉ lệ với số object còn sống, nên dọn thường xuyên mà ít tốn.

  • Minor (young) GC: dọn Eden và Survivor, chép object sống sang Survivor hoặc lên Old. Thường vài ms tới vài chục ms.
  • Major/mixed: dọn old (G1 mixed GC dọn young cùng vài region old nhiều rác nhất).
  • Full GC: dọn toàn heap trong một lần dừng; với G1 là dấu hiệu GC không theo kịp (promotion quá nhanh, humongous object, heap quá nhỏ).
G1 và ZGC khác nhau thế nào? Khi nào bạn chọn ZGC?

G1 chia heap thành region và chép object khi dừng app, nhắm pause ~200 ms; ZGC dời object song song với app nhờ load barrier, pause dưới 1 ms gần như không phụ thuộc heap, đổi lại tốn CPU hơn.

G1 là mặc định tốt cho đa số service: throughput cao, ít CPU phụ. Chọn ZGC khi GC pause hiện rõ trong p99 (khớp GC log với latency spike), heap lớn hàng chục GB, hoặc SLO latency chặt, và máy dư CPU 10–20%. Quyết định bằng load test so p99, CPU, throughput. Lưu ý phiên bản: ZGC generational từ JDK 21, là chế độ duy nhất từ JDK 24.

Humongous object trong G1 là gì và vì sao nó gây vấn đề?

Object lớn từ nửa region trở lên được cấp phát thẳng vào các region liên tiếp riêng (humongous region), bỏ qua Eden.

Vấn đề: tốn trọn region dù chỉ dùng một phần (phân mảnh), cần nhiều region liền nhau nên dễ kích hoạt GC hay Full GC khi heap còn chỗ nhưng rời rạc, và mỗi lần cấp phát humongous có thể khởi động một chu kỳ mark. Gặp nhiều trong log (Humongous Allocation): giảm mảng/buffer lớn (đọc stream thay vì byte[] cả file, chia batch), hoặc tăng -XX:G1HeapRegionSize (1–512 MB từ JDK 18).

Heap còn trống mà app vẫn OutOfMemoryError. Có thể là những loại nào?

Những OOM không phải của heap: Metaspace, Cannot reserve ... direct buffer memory, unable to create native thread, hoặc Requested array size exceeds VM limit; và nếu pod bị kill với exit 137 thì là OOMKilled của kernel, không phải OOM của Java.

Đọc phần sau dấu hai chấm để biết vùng nào. Metaspace: class sinh động hoặc loader leak. Direct buffer: Netty/NIO, chỉnh MaxDirectMemorySize. Native thread: pool không giới hạn, ulimit/pids.max. OOMKilled: tổng RSS (heap + metaspace + stack + direct + code cache) vượt limit, giảm MaxRAMPercentage và đo bằng NMT.

Bạn nghi service bị memory leak trên production. Bạn làm gì, theo thứ tự?

Xác nhận bằng số (heap sau GC tăng đều nhiều giờ), so GC.class_histogram hai thời điểm, lấy heap dump từ một instance đã rút khỏi traffic, phân tích dominator tree và path to GC roots trong MAT, sửa rồi chứng minh bằng soak test.

Trong lúc chờ sửa có thể giảm thiệt hại bằng restart định kỳ hoặc tăng heap, nhưng nói rõ đó là băng dán. Nguồn leak hay gặp: cache không giới hạn, ThreadLocal không remove, listener không gỡ, collection trong bean singleton chỉ thêm, kết quả query không phân trang. Nhắc bảo mật: heap dump chứa dữ liệu thật.

-Xms bằng -Xmx có nên không? Bạn chỉnh GC những gì?

Với service chạy lâu, đặt bằng nhau là hợp lý: tránh co giãn heap và biết trước bộ nhớ chiếm; trong container thì dùng MaxRAMPercentage/InitialRAMPercentage theo limit.

Ngoài heap, thường chỉ cần: chọn collector, (G1) MaxGCPauseMillis nếu có mục tiêu rõ, bật GC log có xoay vòng, HeapDumpOnOutOfMemoryError, ExitOnOutOfMemoryError. Không đặt -Xmn/NewRatio cho G1 và không chép cờ CMS. Mọi chỉnh khác phải đi kèm GC log trước và sau.

GC overhead limit exceeded nghĩa là gì?

JVM đã dành hơn 98% thời gian cho GC mà mỗi lần chỉ thu hồi được dưới 2% heap, nên nó bỏ cuộc thay vì để app chạy lết.

Bản chất giống Java heap space: dữ liệu sống gần bằng heap (leak hoặc heap quá nhỏ). Lỗi này chỉ Parallel GC ném; với G1 (mặc định) bạn thấy thẳng Java heap space. Xử lý như heap OOM: heap dump, tìm ai giữ bộ nhớ.

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
GC root /ˌdʒiː ˈsiː ruːt/ điểm gốc để dò object sống “Anything reachable from a GC root survives the collection.”
stop-the-world pause /stɑːp ðə wɝːld pɑːz/ khoảng dừng toàn bộ app “G1 still has stop-the-world pauses when it evacuates regions.”
premature promotion /ˌpriː.məˈtʃʊr prəˈmoʊ.ʃən/ đẩy lên old quá sớm “Premature promotion fills the old generation with short-lived data.”
live set /laɪv set/ lượng dữ liệu còn sống “Pause times for copying collectors grow with the live set.”
humongous object /hjuːˈmʌŋ.ɡəs ˈɑːb.dʒekt/ object lớn ≥ nửa region (G1) “Large byte arrays become humongous objects in G1.”
load barrier /loʊd ˈbær.i.ɚ/ đoạn kiểm tra khi đọc tham chiếu “ZGC uses load barriers to relocate objects concurrently.”
allocation rate /ˌæl.əˈkeɪ.ʃən reɪt/ tốc độ cấp phát “A high allocation rate means more frequent young collections.”
heap dump /hiːp dʌmp/ ảnh chụp toàn bộ heap “We always enable heap dumps on OutOfMemoryError in production.”
retained size /rɪˈteɪnd saɪz/ bộ nhớ được giải phóng nếu object mất “I sort the dominator tree by retained size, not shallow size.”
memory leak /ˈmem.ɚ.i liːk/ giữ tham chiếu không cần nữa “In Java, a memory leak is a reference you forgot to drop.”

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