Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.
JVM bên trong: các vùng nhớ runtime, nạp class và ClassLoader
1Các vùng nhớ runtime
Mỗi thread có riêng PC register (đang chạy tới lệnh nào) và stack; mọi thread dùng chung heap, metaspace và code cache.
Vùng
Chứa gì
Đầy thì
Stack (mỗi thread)
frame: biến cục bộ, operand
StackOverflowError
Heap (chung)
object, mảng, object Class
Java heap space
Metaspace (native)
metadata class, bytecode
OOM: Metaspace
Code cache
mã máy do JIT sinh
JIT dừng, app chậm hẳn
2Field static nằm ở đâu
Từ JDK 8, PermGen bị bỏ: giá trị field static nằm trong object Class (class mirror) trên heap, metaspace chỉ giữ metadata.
class Booking {
static int created; // trong Booking.class, heap
final String code; // trong object Booking, heap
void f() {
int n = 1; // trong frame, stack
}
}
3Vòng đời một class
Class được nạp lười. <clinit> (gán static, khối static {}) chỉ chạy ở lần dùng thật đầu tiên, đúng một lần, dưới lock của JVM.
flowchart TD
L["Loading: đọc bytes, tạo Class"] --> V["Verify: bytecode hợp lệ"]
V --> P["Prepare: static = 0/null"]
P --> R["Resolve: tên → địa chỉ"]
R --> I["Initialize: chạy clinit"]
4Cây ClassLoader
Parent delegation: hỏi loader cha trước, cha không có mới tự nạp. Nhờ vậy java.lang.String luôn là bản của JDK và chỉ có một bản.
flowchart TD
C["Loader riêng: Tomcat, Spring Boot"] --> A["Application: classpath"]
A --> P["Platform: java.sql, java.xml"]
P --> B["Bootstrap: java.base"]
5Đọc lỗi nạp class
Một class được xác định bởi tên + loader đã định nghĩa nó. Hai loader nạp cùng file .class cho ra hai kiểu khác nhau.
Lỗi
Nguyên nhân hay gặp
X cannot be cast to X
Hai loader nạp cùng class
ClassNotFoundException
Chủ động nạp theo tên, không thấy
NoClassDefFoundError
Thiếu jar lúc chạy, hoặc <clinit> từng lỗi
6ClassLoader leak khi redeploy
Loader chỉ được dỡ khi không còn gì trỏ tới class hay object nó nạp. Một đường dây sót lại là metaspace phình sau mỗi lần redeploy.
Xong phần tự kiểm tra, bài này đã được đánh dấu đã học ✓
⚠️ Lỗi thường gặp
Nói "static nằm trong method area": đó là mô hình trước JDK 8.
Để <clinit> đọc file, mở connection; lỗi thành NoClassDefFoundError mãi.
Đặt memory limit container chỉ theo -Xmx, quên metaspace và stack.
Phỏng vấn senior Java gần như luôn có câu “JVM chia bộ nhớ thế nào” và “ClassLoader hoạt động ra sao”. Bài này trả lời hai câu đó bằng thí nghiệm trên JDK 21, đủ để bạn đọc được lỗi StackOverflowError, Metaspace, ClassCastException: Cannot cast X to X và biết nó đến từ vùng nào. GC và các loại OutOfMemoryError nằm ở bài tiếp theo.
Sơ đồ tóm tắt:
flowchart LR
SRC[".java"] -->|javac| CLS[".class bytecode"]
CLS --> CL["ClassLoader: load, link, init"]
CL --> META["Metaspace: metadata class"]
CL --> MIRROR["Object Class trên heap: field static"]
META --> EXE["Execution engine"]
EXE --> INT["Interpreter"]
EXE --> JIT["JIT C1/C2 → code cache"]
EXE --> T["Mỗi thread: PC + stack frame"]
T --> HEAP["Heap: object, mảng"]
HEAP --> GC["GC dọn object không còn reachable"]
1. Các vùng nhớ runtime
Ý chính: JVM spec định nghĩa năm vùng: ba vùng riêng cho mỗi thread (PC register, JVM stack, native method stack) và hai vùng dùng chung (heap, method area). HotSpot hiện thực method area bằng metaspace (bộ nhớ native ngoài heap) và thêm code cache cho code đã JIT.
Vùng
Riêng hay chung
Chứa gì
Lỗi khi đầy
PC register
mỗi thread
vị trí lệnh bytecode đang chạy (rỗng khi đang ở method native)
không có
JVM stack
mỗi thread
các frame: biến cục bộ, operand stack, địa chỉ trả về
StackOverflowError
Native method stack
mỗi thread
frame của code C/C++ (JNI)
StackOverflowError
Heap
chung
mọi object, mảng, object Class, string pool
OutOfMemoryError: Java heap space
Metaspace
chung
metadata class: method, field, bytecode, runtime constant pool
OutOfMemoryError: Metaspace
Code cache
chung
mã máy do JIT sinh ra
JIT tắt, app chậm hẳn (cảnh báo CodeCache is full)
Ngoài ra còn bộ nhớ native khác: thread stack thật của OS, direct buffer, cấu trúc của GC. Tổng các vùng này mới là RSS (bộ nhớ process đang chiếm thật), chi tiết ở JVM trong container.
public class Booking { static int created = 0; // field static: nằm trong object Booking.class (heap) private final String code; // field instance: nằm trong object Booking (heap) Booking(String code) { this.code = code; created++; } static Booking open(String code) { int len = code.length(); // biến cục bộ: nằm trong frame của open() trên stack Booking b = new Booking(code); // b (tham chiếu) trong frame, object trên heap return b; }}
Stack frame và PC register
Ý chính: mỗi lần gọi method, JVM đẩy một frame lên stack của thread; method trả về thì frame bị bỏ. PC register của thread trỏ tới lệnh bytecode tiếp theo trong method hiện tại; nhờ nó, khi OS chuyển thread, thread quay lại đúng chỗ.
Xem bytecode bằng javap -c -p Room:
int total(int pricePerNight) { int sum = nights * pricePerNight; if (sum > 1000) sum -= 50; return sum;}
0: aload_0 // slot 0 là this 1: getfield #7 // Field nights:I 4: iload_1 // slot 1 là pricePerNight 5: imul 6: istore_2 // slot 2 là sum 7: iload_2 8: sipush 100011: if_icmple 17 // sum <= 1000 thì PC nhảy tới 1714: iinc 2, -5017: iload_218: ireturn
Con số bên trái là offset; PC register giữ đúng con số này. Lệnh nhảy (if_icmple, goto) chỉ là gán PC.
this không có gì đặc biệt ở mức bytecode: nó là biến cục bộ slot 0 của method instance. Method static không có slot đó, nên không có this.
JVM là máy dùng stack: phép tính đẩy toán hạng lên operand stack rồi lấy xuống (iload, imul, istore).
StackOverflowError xảy ra khi đệ quy quá sâu làm stack của thread hết chỗ. Kích thước đặt bằng -Xss (mặc định 1 MB trên Linux x64); với stack mặc định, hàm đệ quy nhỏ trong thí nghiệm sâu được vài chục nghìn tầng, tuỳ kích thước frame và việc method đã được JIT chưa.
cố định theo class được ghi trong lệnh, không tra theo kiểu thật
invokevirtual
method instance của class
lúc chạy, theo kiểu thật của object (bảng vtable)
invokeinterface
method qua kiểu interface
lúc chạy, tra itable
invokedynamic
lambda, nối chuỗi (JDK 9+), switch theo pattern
lần đầu gọi một bootstrap method để quyết định, sau đó gắn cố định
Từ JDK 11 (nestmates), method private gọi trong cùng class thường dùng invokevirtual, nhưng vẫn không bị override vì method private không có trong vtable. Chi tiết dynamic dispatch và chi phí của nó ở kế thừa và đa hình.
2. Vòng đời một class: loading, linking, initialization
Ý chính: JVM nạp class lười (lazy): chỉ khi cần. Mỗi class đi qua loading (đọc bytecode, tạo metadata và object Class), linking (verify bytecode an toàn, prepare cấp giá trị mặc định cho field static, resolve tham chiếu tượng trưng thành tham chiếu thật) rồi initialization (chạy <clinit>: các phép gán static và khối static {} theo thứ tự viết).
flowchart LR
L["Loading: đọc bytes, tạo Class"] --> V["Verify: bytecode hợp lệ"]
V --> P["Prepare: static = 0/null"]
P --> R["Resolve: tên → địa chỉ (có thể lười)"]
R --> I["Initialize: chạy clinit một lần"]
Khởi tạo (bước chạy code của bạn) chỉ xảy ra ở lần dùng chủ động đầu tiên:
new, gọi method static, đọc hoặc ghi field static không phải hằng.
Class.forName(name) (mặc định có khởi tạo), reflection gọi method.
Khởi tạo lớp con thì lớp cha được khởi tạo trước. Class chứa main được khởi tạo khi chạy.
Không kích hoạt khởi tạo: đọc hằng compile-time (static final int X = 42, được chép thẳng vào class dùng nó), ClassLoader.loadClass, Class.forName(name, false, loader), khai báo mảng Config[]. Chạy thử:
1. đọc Config.CONST = 42 ← hằng: không khởi tạo2. loadClass xong: Config ← mới loading3. forName(init=false) xong Config <clinit> chạy ← lần đầu đọc field không phải hằng4. đọc Config.value = 75. forName lần nữa: không in lại ← <clinit> chỉ chạy một lần
JVM giữ lock trong lúc chạy <clinit>, nên khởi tạo class là thread-safe sẵn. Đó là nền của holder idiom cho singleton lười (xem tạo object đúng cách). Mặt trái: <clinit> ném exception thì class hỏng vĩnh viễn trong loader đó; lần đầu thấy ExceptionInInitializerError, các lần sau thấy NoClassDefFoundError: Could not initialize class.
3. Cây ClassLoader và parent delegation
Ý chính: từ JDK 9 có ba loader dựng sẵn: bootstrap (viết bằng C++, nạp java.base), platform (các module như java.sql), application (classpath của bạn). Mỗi loader trước khi tự tìm sẽ hỏi loader cha; nhờ vậy java.lang.String luôn là bản của JDK và chỉ có một bản.
flowchart BT
APP["Application: classpath, -cp"] --> PLAT["Platform: java.sql, java.xml..."]
PLAT --> BOOT["Bootstrap: java.base (null trong Java)"]
CUSTOM["Loader tự viết / của Tomcat / Spring Boot"] --> APP
Kết quả chạy thật trên JDK 21:
String -> null // bootstrap hiện ra là nulljava.sql -> platformMain -> appapp parent -> platform
Logic trong ClassLoader.loadClass (rút gọn):
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { synchronized (getClassLoadingLock(name)) { Class<?> c = findLoadedClass(name); // 1. đã nạp rồi thì trả luôn if (c == null) { try { c = (parent != null) ? parent.loadClass(name, false) : findBootstrapClassOrNull(name); // 2. hỏi cha } catch (ClassNotFoundException ignored) { } if (c == null) c = findClass(name); // 3. cha không có: tự tìm } return c; }}
Viết loader riêng thì override findClass, không override loadClass, để giữ nguyên delegation: đọc bytes từ đâu cũng được (file, jar, mạng, mã hoá) rồi gọi defineClass.
Vì sao cần delegation:
An toàn: app không thể thay java.lang.String hay System bằng bản của mình. Thử định nghĩa class trong package java.* từ loader thường, JVM ném SecurityException: Prohibited package name: java.lang.
Một bản duy nhất: mọi loader đều thấy cùng một Object, String, nên object truyền qua lại giữa các phần của app vẫn cùng kiểu.
Không phải loader nào cũng hỏi cha trước. Tomcat cho mỗi web app một loader child-first (tìm trong WEB-INF/lib trước, trừ class của JDK và Servlet API) để hai app dùng được hai phiên bản thư viện khác nhau. Spring Boot fat jar dùng LaunchedClassLoader để đọc jar lồng trong BOOT-INF/lib (xem Maven và fat jar).
ClassLoader leak: vì sao metaspace phình sau mỗi lần redeploy
Một class chỉ được dỡ (unload) khi loader của nó không còn reachable; mà loader còn reachable chừng nào bất kỳ class, object hay Class nào nó nạp còn được giữ. Chỉ cần một đường dây từ GC root tới một object của app cũ là toàn bộ class của app cũ ở lại metaspace.
Các đường dây hay gặp khi redeploy trên app server hoặc reload plugin:
Thread do app tạo mà không dừng (scheduler, thread pool): thread là GC root, contextClassLoader của nó trỏ về loader cũ.
ThreadLocal trên thread của server giữ object của app (thread sống qua nhiều lần deploy).
Đăng ký vào thứ do loader cha giữ: JDBC driver trong DriverManager, listener trong thư viện dùng chung, Runtime.addShutdownHook.
Cache static trong thư viện dùng chung giữ object của app.
Triệu chứng: sau vài lần redeploy, OutOfMemoryError: Metaspace. Kiểm tra bằng jcmd <pid> VM.classloader_stats (số loader và số class mỗi loader) hoặc heap dump: tìm nhiều instance loader của app (ví dụ ParallelWebappClassLoader) và xem “path to GC roots”. Với service chạy trong container, mỗi lần deploy là một JVM mới nên vấn đề này ít gặp hơn; nó quay lại với code sinh class động không giới hạn (proxy, script engine, Groovy).
4. Execution engine: interpreter, JIT và code cache
Ý chính: bytecode được thông dịch trước; method nào gọi nhiều thì JIT biên dịch thành mã máy, cất trong code cache. HotSpot dùng tiered compilation: C1 biên dịch nhanh, ít tối ưu; method rất nóng được C2 biên dịch lại với tối ưu mạnh dựa trên số liệu đã thu (kiểu thật hay gặp, nhánh hay đi).
Nhờ số liệu lúc chạy, JIT làm được điều compiler tĩnh không dám: inline method ảo khi chỉ thấy một kiểu thật, bỏ kiểm tra thừa. Nếu giả định sai (một kiểu mới xuất hiện), JVM deoptimize quay về thông dịch rồi biên dịch lại.
Hệ quả vận hành: service vừa khởi động chậm hơn lúc đã “ấm”; benchmark phải có warm-up (dùng JMH). Ảnh hưởng tới deploy và autoscale có ở câu hỏi JIT trong Java cơ bản.
Code cache đầy (app rất lớn, nhiều code sinh động) thì JIT dừng biên dịch thêm, app chạy chậm hẳn mà không có exception; tăng bằng -XX:ReservedCodeCacheSize.
Bài tập
Bài 1: hai loader, hai kiểu
Đề: viết DirLoader extends ClassLoader đọc file .class từ một thư mục. Dùng hai instance để nạp cùng Greeter (có field static int counter và method hello() tăng counter), rồi chứng minh: hai Class khác nhau, field static tách biệt, object của loader này không cast được sang kiểu của loader kia.
Lời giải Bài 1
Cha của loader là platform loader, không phải app loader; nếu không, app loader (thấy cùng thư mục qua classpath) sẽ nạp Greeter trước và cả hai loader nhận chung một class.
// plugin/Greeter.java (biên dịch riêng: javac -d plugin plugin/Greeter.java)public class Greeter { public static int counter = 0; public String hello() { counter++; return "hello #" + counter; }}
import java.nio.file.*;public class Main { static class DirLoader extends ClassLoader { private final Path dir; DirLoader(Path dir, ClassLoader parent) { super(parent); this.dir = dir; } @Override protected Class<?> findClass(String name) throws ClassNotFoundException { try { byte[] b = Files.readAllBytes(dir.resolve(name.replace('.', '/') + ".class")); return defineClass(name, b, 0, b.length); } catch (java.io.IOException e) { throw new ClassNotFoundException(name, e); } } } public static void main(String[] args) throws Exception { Path dir = Path.of(args[0]); ClassLoader a = new DirLoader(dir, ClassLoader.getPlatformClassLoader()); ClassLoader b = new DirLoader(dir, ClassLoader.getPlatformClassLoader()); Class<?> ga = a.loadClass("Greeter"); Class<?> gb = b.loadClass("Greeter"); System.out.println("same class -> " + (ga == gb)); Object oa = ga.getDeclaredConstructor().newInstance(); Object ob = gb.getDeclaredConstructor().newInstance(); System.out.println("a.hello -> " + ga.getMethod("hello").invoke(oa)); System.out.println("a.hello -> " + ga.getMethod("hello").invoke(oa)); System.out.println("b.hello -> " + gb.getMethod("hello").invoke(ob)); System.out.println("isInstance -> " + ga.isInstance(ob)); try { ga.cast(ob); } catch (ClassCastException e) { System.out.println("cast -> " + e.getMessage()); } }}
same class -> falsea.hello -> hello #1a.hello -> hello #2b.hello -> hello #1isInstance -> falsecast -> Cannot cast Greeter to Greeter
Đây cũng là cách plugin system và app server cô lập phiên bản thư viện, và cũng là lý do một “singleton” có thể có hai bản trong cùng JVM.
Bài 2: đoán thứ tự khởi tạo
Đề: với class lồng Config có khối static { println("Config <clinit> chạy") }, hằng static final int CONST = 42 và static int value = 7, đoán dòng nào in ra trước dòng “Config chạy”: đọc Config.CONST, loader.loadClass("Init$Config"), Class.forName("Init$Config", false, loader), đọc Config.value, gọi Class.forName("Init$Config") lần hai.
Lời giải Bài 2
Ba thao tác đầu không khởi tạo: hằng compile-time được chép thẳng vào Init, loadClass và forName(..., false, ...) chỉ nạp. Lần đọc Config.value (field không phải hằng) kích hoạt <clinit>. forName lần sau thấy class đã khởi tạo nên không chạy lại.
public class Init { static class Config { static { System.out.println(" Config <clinit> chạy"); } static final int CONST = 42; static int value = 7; } public static void main(String[] args) throws Exception { System.out.println("1. đọc Config.CONST = " + Config.CONST); ClassLoader cl = Init.class.getClassLoader(); Class<?> c = cl.loadClass("Init$Config"); System.out.println("2. loadClass xong: " + c.getSimpleName()); Class.forName("Init$Config", false, cl); System.out.println("3. forName(init=false) xong"); System.out.println("4. đọc Config.value = " + Config.value); Class.forName("Init$Config"); System.out.println("5. forName lần nữa: không in lại"); }}
Kết quả chạy đúng như bảng ở mục 2. Bài học khi làm thư viện: đừng để <clinit> làm việc nặng hay dễ lỗi (đọc file, mở connection); lỗi ở đó biến thành NoClassDefFoundError khó đọc ở mọi lần dùng sau.
Ghi nhớ
Kể được vùng nhớ nào riêng cho thread, vùng nào dùng chung, và mỗi vùng đầy thì ra lỗi gì.
Giải thích được vì sao field static và string pool nằm trên heap từ JDK 7/8, còn metaspace chỉ giữ metadata.
Biết thao tác nào kích hoạt khởi tạo class và vì sao khởi tạo class là thread-safe.
Vẽ được cây ClassLoader, mô tả parent delegation và lý do tồn tại của nó.
Chẩn đoán được X cannot be cast to X và metaspace phình sau redeploy.
Câu hỏi phỏng vấn
JVM chia bộ nhớ thành những vùng nào?
Ba vùng riêng cho mỗi thread (PC register, JVM stack, native stack) và hai vùng dùng chung (heap, method area mà HotSpot cài bằng metaspace); HotSpot thêm code cache cho code đã JIT.
Heap: object, mảng, object Class (chứa field static), string pool. GC quản lý. Đầy: Java heap space.
Metaspace: metadata class, bytecode method, runtime constant pool; nằm ở bộ nhớ native. Đầy: OutOfMemoryError: Metaspace.
Stack: frame của mỗi lần gọi method (biến cục bộ, operand stack). Đầy: StackOverflowError.
PC register: offset lệnh bytecode đang chạy của thread.
Câu nối tiếp hay gặp: tổng các vùng này lớn hơn -Xmx nhiều, nên đặt memory limit container chỉ theo heap là sai.
Biến static nằm ở đâu trong bộ nhớ?
Từ JDK 8, giá trị của field static nằm trong object java.lang.Class của class đó, trên heap; metaspace chỉ giữ metadata mô tả field.
Trước JDK 8, chúng ở PermGen. Hệ quả: một static collection phình to gây Java heap space và được GC coi là reachable chừng nào class còn được nạp (class mirror là GC root qua loader). Tài liệu cũ nói “static nằm trong method area” là theo mô hình trước JDK 8.
PC register lấy địa chỉ lệnh tiếp theo từ đâu? Vì sao mỗi thread cần một PC riêng?
Bytecode của method nằm trong metaspace; PC register của thread chỉ giữ offset lệnh đang chạy trong method hiện tại và được cập nhật sau mỗi lệnh hoặc khi nhảy.
Bytecode dùng chung cho mọi thread và không đổi, còn “đang chạy tới đâu” thì mỗi thread mỗi khác. Nhiều thread chạy cùng một method ở các offset khác nhau, và khi OS chuyển thread (context switch), thread quay lại phải tiếp đúng offset của nó. Đang ở method native thì PC không xác định vì JVM không quản lý code đó.
Mô tả quá trình nạp một class. Khi nào static block chạy?
Loading (đọc bytecode, tạo metadata và object Class), linking (verify, prepare, resolve), initialization (chạy <clinit>); static block chạy ở bước cuối, vào lần dùng chủ động đầu tiên.
Lần dùng chủ động: new, gọi method static, đọc/ghi field static không phải hằng, Class.forName(name), khởi tạo lớp con. Không kích hoạt: đọc hằng compile-time, loadClass, khai báo mảng. <clinit> chạy đúng một lần dưới lock của JVM; nếu nó ném exception thì các lần sau gặp NoClassDefFoundError: Could not initialize class.
Parent delegation model là gì và vì sao Java cần nó?
Mỗi ClassLoader hỏi loader cha trước khi tự nạp; chỉ khi cha không tìm thấy, nó mới gọi findClass của chính mình.
Thứ tự từ JDK 9: application → platform → bootstrap. Lợi ích: class lõi như String luôn là bản của JDK và chỉ có một bản (an toàn, nhất quán kiểu), và class không bị nạp lặp. Loader tự viết nên override findClass chứ không phải loadClass để giữ cơ chế này. Ngoại lệ có chủ đích: Tomcat dùng child-first cho mỗi web app để cô lập phiên bản thư viện.
Bạn gặp ClassCastException: com.acme.Order cannot be cast to com.acme.Order. Chuyện gì xảy ra?
Class Order bị nạp bởi hai ClassLoader khác nhau; với JVM đó là hai kiểu khác nhau dù cùng tên và cùng bytecode.
Nguyên nhân hay gặp: Spring Boot DevTools (restart loader nạp code app, object được tạo trước restart hoặc từ thư viện cache ở loader khác), jar trùng ở thư mục server và app, plugin nạp jar riêng, deserialize bằng loader sai. Cách xử lý: in obj.getClass().getClassLoader() ở hai phía, chạy -Xlog:class+load để xem class được nạp từ đâu, bỏ jar trùng, hoặc đưa kiểu dùng chung lên loader cha.
ClassNotFoundException và NoClassDefFoundError khác nhau thế nào? Bạn xử lý ra sao?
ClassNotFoundException là exception khi chủ động nạp theo tên mà không thấy; NoClassDefFoundError là Error khi class có lúc biên dịch nhưng không nạp hoặc không khởi tạo được lúc chạy.
Các bước: đọc Caused by đầu tiên; kiểm tra tên đầy đủ và package; xem jar có trong artifact chạy thật không (jar tf, mvn dependency:tree, scope provided/test); xem có hai phiên bản thư viện xung đột không (thiếu method thì thường là NoSuchMethodError); nếu là Could not initialize class thì tìm exception đầu tiên trong <clinit> ở log trước đó.
Metaspace tăng sau mỗi lần redeploy trên Tomcat. Bạn điều tra thế nào?
Gần như chắc là ClassLoader leak: một thứ sống lâu hơn app (thread, ThreadLocal, driver JDBC, cache của thư viện dùng chung) giữ reference tới object của app cũ, nên loader cũ và mọi class của nó không được dỡ.
Điều tra: jcmd <pid> VM.classloader_stats hoặc GC.class_histogram để thấy số loader của app tăng; lấy heap dump, tìm các instance loader của app, xem đường tới GC root. Sửa: dừng thread và executor khi app shutdown, ThreadLocal.remove(), deregister driver JDBC, gỡ listener. Tomcat có cảnh báo “appears to have started a thread… but has failed to stop it” rất đáng đọc. Đặt -XX:MaxMetaspaceSize để lỗi đến sớm và rõ thay vì ăn hết RAM.
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
runtime data area
/ˈrʌn.taɪm ˈdeɪ.tə ˈer.i.ə/
vùng nhớ lúc chạy
“The JVM spec defines per-thread and shared runtime data areas.”
stack frame
/stæk freɪm/
khung của một lần gọi method
“Each method call pushes a frame with locals and an operand stack.”
metaspace
/ˈmet.ə.speɪs/
vùng metadata class (native)
“Metaspace replaced PermGen in Java 8 and lives in native memory.”
class mirror
/klæs ˈmɪr.ɚ/
object Class đại diện class
“Static fields are stored in the class mirror on the heap.”
parent delegation
/ˈper.ənt ˌdel.əˈɡeɪ.ʃən/
hỏi loader cha trước
“Parent delegation guarantees a single java.lang.String.”
defining loader
/dɪˈfaɪ.nɪŋ ˈloʊ.dɚ/
loader đã định nghĩa class
“A class is identified by its name plus its defining loader.”
static initializer
/ˈstæt.ɪk ɪˈnɪʃ.əl.aɪ.zɚ/
khối khởi tạo static
“The static initializer runs once, under a lock held by the JVM.”
tiered compilation
/tɪrd ˌkɑːm.pəˈleɪ.ʃən/
biên dịch nhiều tầng C1/C2
“Tiered compilation starts with C1 and promotes hot methods to C2.”
deoptimization
/diːˌɑːp.tə.məˈzeɪ.ʃən/
bỏ code đã tối ưu, quay về thông dịch
“A new subtype can trigger deoptimization of an inlined call.”
classloader leak
/ˈklæsˌloʊ.dɚ liːk/
rò loader làm class không được dỡ
“A thread that outlives the app is a classic classloader leak.”
Ghi chép tự tổng hợp từ tài liệu chính thức và kinh nghiệm thực tế.