参考:James D. Bloom 的《JVM Internals》(2013,https://blog.jamesdbloom.com/JVMInternals.html)。原文版权归作者所有,本文不是译文。阅读原文后,我按 JVM 规范和 HotSpot 的实际行为重新组织并改写了内容:
- 示例代码、
javap输出和线程列表都来自本机 JDK 21(21.0.9),源码可以直接下载:Greeter.java、Probe.java、Threads.java、Priv.java;- 图都是我自己用 PlantUML 画的,不是照着原文配图描的;
- 原文以 Java SE 7 为准,本文在各节标出到 JDK 21 为止的变化,末尾另有一张汇总表;
- 英文术语以「中文(English)」的形式标出,文末附术语对照表。
0. 全景
运行时数据区可以按「谁能看见」分成两类:
- 线程私有:随线程创建、随线程销毁,不需要同步。包括 PC、Java 栈和本地方法栈。
- 线程共享:整个 JVM 只有一份,并发访问时要么由 JVM 内部加锁,要么交给程序员同步。包括堆、方法区和代码缓存。
1. 线程
1.1 Java 线程与操作系统线程
HotSpot 的平台线程(platform thread)和操作系统线程一一对应。调用 Thread.start() 时,JVM 会创建一个 OS 线程(macOS 和 Linux 上是 pthread),之后什么时候运行、在哪个核上运行,都由操作系统调度。这层对应关系可以直接看到:jcmd <pid> Thread.print 输出的每个线程都带一个 nid,它就是 OS 线程的 ID。下面是本机 JDK 21 的输出:
1 | "main" #1 [6403] prio=5 os_prio=31 tid=0x00000001032c1810 nid=6403 waiting on condition |
#1是 Java 层的线程编号;tid是 JVM 内部线程对象的地址;nid是 OS 线程 ID。
VM Thread 没有 # 编号,因为它是 JVM 自己的线程,没有对应的 java.lang.Thread 对象。
run() 结束后,不管是正常返回还是抛出了异常,对应的 OS 线程都会被回收。进程什么时候退出,取决于非守护线程(non-daemon thread):最后一个非守护线程结束时,JVM 就开始关闭。
JDK 21 变化:虚拟线程(virtual thread,JEP 444)不再一对一绑定 OS 线程。大量虚拟线程轮流挂载(mount)到少量载体线程(carrier thread)上运行,阻塞时卸载,所以「一个 Java 线程 = 一个 OS 线程」只对平台线程成立。
1.2 JVM 自己的后台线程
main 之外,JVM 进程里还有一批自己的线程。下面这张表来自 JDK 21 + 默认的 G1 收集器,用 jcmd <pid> Thread.print 实际列出:
| 线程名 | 职责 |
|---|---|
VM Thread |
执行必须在安全点(safepoint)进行的 VM 操作,例如 Stop-the-World 阶段的 GC、线程转储和去优化。安全点上所有 Java 线程都已停下,不会有人同时修改堆。 |
GC Thread#N、G1 Conc#N、G1 Main Marker、G1 Refine#N、G1 Service |
G1 的工作线程,依次负责:并行回收、并发标记、标记的协调、记忆集(remembered set)维护和 G1 的周期性任务。 |
C1 CompilerThread0、C2 CompilerThread0 |
JIT 编译线程,在运行时把热点字节码编译成本地代码(见 §3.4)。 |
VM Periodic Task Thread |
定时器线程,驱动采样等周期性任务。 |
Signal Dispatcher |
接收发给 JVM 进程的信号并转成 JVM 内部的处理。比如 kill -3 会触发线程转储。 |
Reference Handler、Finalizer、Common-Cleaner |
分别负责:把被回收的软 / 弱 / 虚引用放进引用队列;执行 finalize()(JDK 18 起已弃用);执行 Cleaner 注册的清理动作。 |
Service Thread、Notification Thread、Monitor Deflation Thread |
VM 的杂项后台工作,依次是:内部维护、JMX 等诊断通知、回收空闲的重量级锁(monitor)。 |
Attach Listener |
处理 jcmd、jstack 这类 attach 请求;第一次有工具 attach 时才出现。 |
变化:2013 年的资料会说 VM Thread 负责「撤销偏向锁(biased locking revocation)」。偏向锁从 JDK 15 起默认关闭并被弃用(JEP 374),后来被移除。
2. 线程私有的区域
2.1 程序计数器(Program Counter, PC)
PC 记录当前线程正在执行的那条字节码在方法代码中的位置,而方法代码本身存放在方法区里。在执行本地(native)方法时,PC 的值没有定义。
CPU 也有 PC,所以这个概念并不新鲜。JVM 规范为各个运行时数据区规定了可能抛出的错误,只有 PC 一条都没有。它只存一个位置,大小固定,不会出现内存不够的情况。
2.2 Java 栈与栈帧(Stack, Frame)
每个线程有一个后进先出(LIFO)的栈:
- 每调用一个方法,就压入(push)一个新的栈帧,栈顶的栈帧就是当前正在执行的方法;
- 方法正常返回,或者抛出了本方法内没有处理的异常时,弹出(pop)这个栈帧。
栈的大小限制:
- 调用层次太深、栈用尽时,抛
StackOverflowError; - 栈允许动态扩展但内存不够,或者连新线程的栈都分配不出来时,抛
OutOfMemoryError。常见的报错是unable to create native thread。
HotSpot 的线程栈大小固定,用 -Xss 设置。JVM 规范只要求栈能压入和弹出栈帧,没有要求它是连续内存。HotSpot 的做法则很直接:Java 栈帧就放在 OS 线程的原生栈上。
2.3 本地方法栈(Native Method Stack)
调用 native 方法(通过 JNI)需要按 C 的调用约定传参和返回,所以规范允许为本地方法单独准备一个栈。本地代码也可以通过 JNI 回调 Java 方法,这时会重新在 Java 栈上压一个栈帧。
HotSpot 没有把两者分开:Java 栈帧和本地栈帧交替排在同一个原生线程栈上,-Xss 同时限制它们。
2.4 局部变量表(Local Variables Array)
局部变量表是一个按槽(slot)编号的数组,存放:
this:只有实例方法有,固定在 slot 0;- 方法参数:静态方法从 slot 0 开始,实例方法从 slot 1 开始;
- 方法体里声明的局部变量。
能放进去的类型有 boolean、byte、char、short、int、float、reference、returnAddress,各占 1 个槽;**long 和 double 各占 2 个相邻的槽**。
用 demo/Greeter.java 里的静态方法验证一下:
1 | static long add(int a, long b) { |
javap -v 显示 locals=5:a 占 slot 0,b 占 slot 1–2,sum 占 slot 3–4。下一节的逐步图里能看到每个槽的值怎么变化。
2.5 操作数栈(Operand Stack)
x86、ARM 是寄存器架构,指令里要写明操作数在哪个寄存器。JVM 字节码是栈式指令集,指令默认从操作数栈顶取操作数,结果也压回栈顶,所以大多数指令只有 1 个字节,而且不受任何一种 CPU 寄存器数量的约束。代价是要频繁在局部变量表和操作数栈之间搬运数据。add 编译出的字节码:
1 | 0: iload_0 // 把 slot 0 的 int(a)压栈 |
javap 里的 stack=4 是操作数栈的最大深度。这个方法最深的时候栈里有两个 long,每个 long 算 2 个单位,所以是 4。
2.6 动态链接(Dynamic Linking)
栈帧里那个指向运行时常量池的指针有什么用,看 greet() 里的 invokevirtual #15 就清楚了。这条指令只带一个常量池下标,而 #15 里存的是三段字符串:类 java/io/PrintStream、方法名 println、描述符 (Ljava/lang/String;)V(§4.4 有它的引用关系图)。这种用名字描述的目标叫符号引用(symbolic reference),class 文件里所有对其他类、字段、方法的引用都是这种形式,没有一个是内存地址。
HotSpot 在这条指令第一次执行时才去解析(resolve)它:
- 找到
PrintStream类,如果还没加载就先加载; - 在类里查找名字和描述符都匹配的
println,并检查访问权限; - 得到可以直接使用的直接引用(direct reference),比如这个方法在虚方法表(vtable)里的下标;
- 把结果写进常量池缓存(ConstantPoolCache)。以后这条指令再执行,直接用缓存的结果,不再查名字。
JVM 规范允许实现自己决定什么时候解析:类加载后立刻解析,或者像 HotSpot 这样用到时才解析,都可以。但规范要求解析出错时,表现必须像是在第一次使用时才出错。这就解释了一个常见现象:编译时存在、运行时 jar 里却被删掉的方法,类照样能加载成功,直到第一次调用它时才抛 NoSuchMethodError。
3. 线程共享的区域
3.1 堆(Heap)
一个对象的寿命常常比创建它的方法更长:比如 make() 刚 new 出来就把它返回了,又比如对象被放进了集合。栈帧在方法返回时就整个丢掉了,所以对象不能放在里面。按规范,对象实例和数组都放在堆上,局部变量里只存它们的引用。对象占的内存什么时候回收,看它还能不能从 GC Roots 到达,由垃圾收集器决定,Java 里没有 free。
准确地说,这是语义上的规则。C2 的逃逸分析(escape analysis)如果证明一个对象不会逃出当前方法,可以把它拆成若干标量放进寄存器(标量替换,scalar replacement),这样它就根本不在堆上分配。
3.2 分代与垃圾回收(Generations, GC)
大多数对象很快就会死,活得久的对象往往会一直活下去。基于这个经验,HotSpot 的经典收集器把堆分成几代:
- Minor GC 只回收年轻代:把 Eden 和其中一个 Survivor 里还活着的对象复制到另一个 Survivor;
- 对象熬过的 GC 次数足够多,或者 Survivor 放不下时,晋升到老年代;
- Major / Full GC 会回收老年代乃至整个堆。在老式收集器上它往往要停下所有应用线程(Stop-the-World),停顿也更长。
变化:
- JDK 9 起默认收集器是 G1(JEP 248)。G1 的堆不再是几块连续的大分区,而是切成大小相等的 Region,每个 Region 临时扮演 Eden、Survivor、Old 或 Humongous(存放大对象)的角色,分代仍然保留,只是逻辑上的;
- JDK 21 的 ZGC 也有了分代模式(JEP 439)。
3.3 非堆内存:方法区、代码缓存
有些数据属于 JVM 自身的运行机制,不是 Java 对象,就不放在堆里。这里 2013 年和现在差别最大:
- 方法区在哪:JVM 规范说方法区「逻辑上属于堆」,但允许实现不对它做 GC 或压缩。HotSpot:
- Java 7 用堆旁边单独管理的永久代来实现,大小受
-XX:MaxPermSize限制,类加载得多了容易OutOfMemoryError: PermGen space; - JDK 8 起改成元空间,直接用本地内存,上限用
-XX:MaxMetaspaceSize设置,默认不设上限; - 所以 jconsole 这类工具把方法区和代码缓存都算作「非堆(non-heap)」。
- Java 7 用堆旁边单独管理的永久代来实现,大小受
- 字符串常量池:JDK 7 已经从永久代搬到了堆里。类的静态字段也从 JDK 7 起存放在该类的
java.lang.Class对象里,也就是在堆上。 - 代码缓存:存放 JIT 编译出的本地代码,用
-XX:ReservedCodeCacheSize设置大小。JDK 9 起分成非方法代码、带 profile 的代码、不带 profile 的代码三段(JEP 197)。
3.4 即时编译(Just-In-Time Compilation, JIT)
解释执行字节码比直接跑本地代码慢得多,但把每个方法都先编译成本地代码,启动又会很慢。HotSpot 的折中办法是:先解释执行,同时统计每个方法的调用次数和循环回边次数,只编译真正热的代码。
JDK 8 起默认开启分层编译(tiered compilation):先用 C1 尽快拿到能跑的本地代码,再由 C2 根据运行时收集的 profile 做激进优化。C2 的优化建立在一些假设上,例如「这个虚方法目前只有一个实现」。某个假设被推翻时,比如后来加载了新的子类,JVM 会去优化(deoptimize),退回解释执行。
4. 方法区与 class 文件
4.1 方法区里存放的每个类的信息
在 HotSpot 里,一个类加载后,在元空间中对应一个 Klass 结构(普通类是 InstanceKlass)。它大致连着这些数据:
方法区被所有线程共享,所以类的加载、链接和初始化必须线程安全。两个线程同时首次用到同一个类时,这个类只会被加载、初始化一次,后到的线程会等它完成后才继续(规范 §5.5 用每个类的初始化锁保证这一点)。
4.2 class 文件结构(ClassFile Structure)
class 文件的顶层结构由 JVM 规范 §4.1 定义,u2、u4 分别是 2 字节、4 字节的无符号数,按大端序存放:
1 | ClassFile { |
4.3 用 javap 读 class 文件
1 | javac -g -d out demo/Greeter.java |
greet() 这个方法的源码是 System.out.println("Hi");,javap 输出中对应的部分如下:
1 | public void greet(); |
几个字段的含义:
- **
descriptor**:方法描述符,()V表示无参数、返回 void。类型的写法是:I表示 int,J表示 long,L类名;表示引用类型,[表示数组。 - **
stack/locals/args_size**:依次是操作数栈的最大深度、局部变量表的槽数、参数个数(实例方法把this也算进去)。 - **
LineNumberTable**:字节码偏移量到源码行号的映射,调试器和异常堆栈都用它。这里偏移 0 对应第 5 行,偏移 8 对应第 6 行。 - **
LocalVariableTable**:每个局部变量的作用范围、槽号和类型。只有用-g编译才会生成。 - **
StackMapTable**(parse方法里有):记录每个分支汇合点上局部变量和操作数栈的类型。有了它,验证器只需逐个核对类型,不必再做类型推导。Java 6(class 版本 50)引入,Java 7(版本 51)起成为必需。
字节码在执行时,就是在局部变量表、操作数栈和运行时常量池三者之间来回操作:
常用指令速查:
| 指令 | 作用 |
|---|---|
aload_<n>、iload_<n>、lload_<n>、fload_<n>、dload_<n> |
把局部变量表第 n 个槽(n 只能是 0–3)里的引用 / int / long / float / double 压入操作数栈;n 大于 3 时,改用带一个操作数的 aload n 等形式 |
astore、istore、lstore 等 |
方向相反:弹出栈顶,存入局部变量 |
ldc / ldc2_w |
把运行时常量池里的常量(int、float、String、Class 等;long/double 用 ldc2_w)压栈 |
getstatic / putstatic、getfield / putfield |
读写静态字段 / 实例字段,具体字段由常量池中的 Fieldref 指定 |
new |
分配一个尚未初始化的对象,把引用压栈 |
dup |
复制栈顶的值 |
invokevirtual |
按接收者的实际类型分派,调用普通实例方法。JDK 11 起,同一个类内部调用 private 方法也用它(见下文) |
invokespecial |
不做虚分派:调用构造器 <init> 和 super.xxx() |
invokestatic / invokeinterface |
调用静态方法 / 接口方法 |
invokedynamic |
第一次执行时先调用引导方法(bootstrap method)确定调用目标。lambda 和 JDK 9 起的字符串拼接都用它 |
ireturn、lreturn、freturn、dreturn、areturn、return |
按返回值类型区分;return 用于 void 方法 |
用 JDK 21 编译验证:
- 类内部调用自己的 private 方法
f(),生成的是invokevirtual,这是 JDK 11 嵌套访问控制(nestmates,JEP 181)带来的变化,旧资料会写invokespecial;s + n这样的拼接生成invokedynamic … makeConcatWithConstants。
4.4 运行时常量池(Run-Time Constant Pool)
§4.3 的 javap 输出里,invokevirtual #15 在偏移 5,下一条指令在偏移 8,可见它一共只有 3 个字节:1 个字节的操作码,加 2 个字节的常量池下标。描述目标方法要用的类名、方法名、描述符都在常量池里。类加载时,class 文件里的常量池会转换成运行时常量池,每个类一份。§2.6 里解析的就是它。
常量项之间互相引用。以 #15 为例:
常量池项的类型(JVM 规范 §4.4):
| 类型 | 内容 |
|---|---|
Utf8 |
字符串的字节(修改版 UTF-8),其他各种项最终都指向它 |
Integer / Float |
4 字节常量 |
Long / Double |
8 字节常量,占两个常量池下标 |
String |
指向一个 Utf8,表示字符串字面量 |
Class |
指向一个 Utf8,内容是 JVM 内部格式的全限定名,如 java/lang/Object |
NameAndType |
「名称:描述符」,两部分各指向一个 Utf8 |
Fieldref、Methodref、InterfaceMethodref |
「Class.NameAndType」,前一部分指向 Class 项,后一部分指向 NameAndType 项 |
MethodHandle、MethodType、InvokeDynamic |
Java 7 加入,供 invokedynamic 和方法句柄使用 |
Dynamic |
Java 11 加入,动态计算的常量 |
Module、Package |
Java 9 加入,只出现在 module-info.class 中 |
对象创建的例子:Greeter.make() 方法里写的是 return new Object();,它编译出的字节码是:
1 | 0: new #2 // class java/lang/Object |
需要 dup 是因为构造器调用会从栈上消耗掉一个引用(作为 this),而方法最后还要把这个引用返回出去,所以要先复制一份。左边的数字是字节码偏移量,new 带 2 字节操作数,所以下一条指令从 3 开始。
5. 类加载
5.1 加载、链接、初始化
JVM 启动时,用启动类加载器创建初始类,对它做链接和初始化,然后调用 public static void main(String[])。之后执行代码时遇到别的类,再按需加载、链接、初始化。
- 加载(Loading):按全限定名找到 class 文件的字节流,校验魔数和版本号,解析成方法区里的内部结构,并生成对应的
java.lang.Class对象。直接父类和直接实现的接口会先被加载。 - 验证(Verification):class 文件可能来自网络,也可能是手工构造的,JVM 不能默认它是 javac 的正确产物。字节码验证器借助 §4.3 的
StackMapTable,逐条核对指令执行前后局部变量表和操作数栈里的类型。它要拦下的情况包括:把 int 当成引用来用、弹空操作数栈、跳到一条指令的中间、读取一个还没赋值的局部变量。验证通过后,解释器执行时就能放心地省掉这些检查。 - 准备(Preparation):为静态字段分配内存并置为零值,同时建立方法表等 JVM 内部结构。
static int x = 5;在这一步之后x还是 0。 - 解析(Resolution):把常量池中的符号引用换成直接引用(见 §2.6)。规范允许把这一步推迟到第一次使用时。
- 初始化(Initialization):执行类构造器
<clinit>,也就是静态字段的赋值语句和static {}块,按源码顺序执行,这时x才变成 5。触发初始化的是类的「首次主动使用」,包括:new一个实例、读写静态字段(编译期常量除外)、调用静态方法、反射调用、初始化它的子类,以及它是启动时的主类。
5.2 类加载器的层级与双亲委派
双亲委派(parent delegation):类加载器收到加载请求时,先交给父加载器处理,父加载器找不到,自己才去加载。这保证了 java.lang.Object 这类核心类只能由启动类加载器加载,应用无法用同名的类冒充。
在 JDK 21 上实测(demo/Probe.java):
1 | loader: app jdk.internal.loader.ClassLoaders$AppClassLoader |
| 加载器 | 在 Java 代码里看到的 | JDK 21 中负责的范围 | Java 8 时的对应 |
|---|---|---|---|
| 启动 Bootstrap | null |
java.base 等核心模块(JEP 220 去掉了 rt.jar) |
加载 rt.jar |
| 平台 Platform | 名为 platform,ClassLoaders$PlatformClassLoader |
java.sql、java.xml.crypto 等平台模块 |
扩展类加载器,加载 jre/lib/ext(JDK 9 移除) |
| 应用 App | 名为 app,ClassLoaders$AppClassLoader |
classpath 和模块路径上的应用类 | 名称相同 |
| 自定义 | ClassLoader 的子类 |
热替换、多版本隔离 | 名称相同 |
自定义类加载器不一定遵守双亲委派。Tomcat 给每个 Web 应用一个独立的加载器,除 JDK 核心类仍先交给上层外,先在应用自己的 WEB-INF 里找,找不到再交给父加载器,这样不同应用可以各自带不同版本的同名 jar。
JDK 9 起,内置加载器在委派之前会先看要加载的包属于哪个命名模块;如果这个模块归某个加载器管,就直接交给那个加载器,不再一层层往上问。
5.3 更快的类加载:类数据共享(Class Data Sharing, CDS)
启动一个空的 main 方法也要加载几百个 JDK 类,每个类都要读文件、解析、验证。CDS 的思路是一次做完、结果落盘:把这些类加载后的内部结构写成归档文件,以后启动时用 mmap 直接映射进内存。这样既省掉了重复的解析和验证,同一台机器上的多个 JVM 进程还能共享这部分只读页。
- JDK 5 首次加入;
- JDK 10 起应用类也能放进归档(AppCDS,JEP 310);
- JDK 12 起 JDK 自带一份默认归档(JEP 341),默认就会用上;
- JDK 13 起可以用
-XX:ArchiveClassesAtExit在程序退出时自动生成归档(JEP 350)。
在 JDK 21 上实测,核心类确实来自归档:
1 | $ java -Xlog:class+load=info -cp out2 Probe |
5.4 类与类加载器互相引用
- 每个类都记着定义它的类加载器(
Class.getClassLoader()); - 每个类加载器也持有它加载过的所有类的引用。
结果是:只要类加载器还可达,它加载的类就一个都卸载不掉。如果热部署时旧的类加载器被某个地方意外引用住,比如一个 ThreadLocal、一个没注销的 JDBC 驱动,或者一个还在运行的线程,那么每重新部署一次,元空间就多占一批类,最后抛出 OutOfMemoryError: Metaspace。
6. 异常表(Exception Table)
方法里有 try-catch 或 try-finally 时,它的 Code 属性里会有一张异常表。表的每一行描述一个处理器:在 [from, to) 这段字节码范围内,如果抛出 type 类型的异常,就跳到 target 去执行。用 Greeter.parse() 举例:
1 | int parse(String s) { |
1 | Exception table: |
逐行解读:
try块(偏移 0–4)里抛出NumberFormatException时,跳到 15,也就是 catch 块;try块里抛出任何其他异常时,跳到 28。这是 finally 的「异常出口」:先执行 finally 的代码,再把异常重新抛出(athrow);- catch 块(15–17)自己又抛出异常时,同样跳到 28;
- 最后一行覆盖的是 28 处的
astore本身,属于 javac 生成的兜底条目。
finally 是怎么实现的:从 JDK 21 的字节码可以看到,System.out.println("done") 一共出现了三次,分别在 try 正常返回前(偏移 5–10)、catch 返回前(18–23)和异常出口里(30–35)。现代 javac 会把 finally 块复制到每一条出口路径上,再用 any 类型的处理器兜住其余情况。早年的 jsr/ret 子程序跳转方案已经淘汰,规范规定版本号 51(Java 7)及以上的 class 文件不得再包含 jsr 指令。
抛出异常后,JVM 按下面的流程查找处理器:
7. 符号表与字符串表(Symbol Table, String Table)
除了每个类各自的运行时常量池,HotSpot 还有两张全局哈希表:
- 符号表(SymbolTable):
Greeter常量池里的java/lang/Object,和其他成千上万个类常量池里的java/lang/Object,在 HotSpot 内部指向同一个Symbol。类名、方法名、描述符这些 UTF-8 串在整个 JVM 里只存一份,放在本地内存,不再被引用时清理。 - 字符串表(StringTable):存放被驻留(intern)的
String对象,用来实现 JLS §3.10.5 的规定:内容相同的字符串字面量必须是同一个对象,intern()也返回这个唯一的实例。
1 | String a = new String("jvm"); |
上面的结果在 JDK 21 上实测过(demo/Probe.java)。另外,"j" + "v" + "m" 这种全部由常量组成的表达式,**在编译期就被折叠成 "jvm"**,不调 intern() 也会和 "jvm" 相等。
- 字符串字面量不是在类加载时就进入字符串表的。HotSpot 采用懒解析,某条
ldc指令第一次执行时,才会创建或查找对应的String,并把它驻留到表里。 - JDK 7 起,被驻留的
String对象放在堆上,可以被 GC 回收。表的桶数可以用-XX:StringTableSize调整。
8. 从 2013 年到 JDK 21:变化一览
| 主题 | Java 7 时代(2013) | JDK 21 |
|---|---|---|
| 方法区的实现 | 永久代 PermGen | 元空间 Metaspace,本地内存(JDK 8,JEP 122) |
| 字符串常量池 | 旧资料常写「在永久代」 | 堆(JDK 7 已经迁移) |
| 默认 GC | Parallel | G1(JDK 9,JEP 248);另有分代 ZGC(JEP 439) |
| JIT | C1 / C2,可选分层编译 | 分层编译默认开启(JDK 8);代码缓存分段(JDK 9,JEP 197) |
| 线程模型 | Java 线程与 OS 线程 1:1 | 平台线程仍是 1:1,另有虚拟线程 M:N(JEP 444) |
| 偏向锁 | 默认开启 | 默认关闭并弃用(JDK 15,JEP 374),之后被移除 |
| 核心类库的存放形式 | rt.jar |
模块化运行时镜像(JDK 9,JEP 220) |
| 扩展类加载器 | Extension ClassLoader | Platform ClassLoader |
| CDS | 只覆盖 JDK 自带类,需要手动生成归档 | AppCDS(JEP 310)、默认归档(JEP 341)、动态归档(JEP 350) |
| 类内部调用 private 方法 | invokespecial |
invokevirtual(nestmates,JEP 181) |
| 字符串拼接 | 编译成 StringBuilder 调用链 |
invokedynamic(JDK 9,JEP 280) |
| class 文件主版本号 | 51 | 65 |
9. 术语对照
| 中文 | English |
|---|---|
| 程序计数器 | Program Counter (PC) |
| 栈帧 | Frame |
| 局部变量表 / 槽 | Local Variables Array / Slot |
| 操作数栈 | Operand Stack |
| 本地方法栈 | Native Method Stack |
| 动态链接 | Dynamic Linking |
| 符号引用 / 直接引用 | Symbolic Reference / Direct Reference |
| 解析 | Resolution |
| 堆 / 年轻代 / 老年代 | Heap / Young Generation / Old (Tenured) Generation |
| 晋升 | Promotion |
| 永久代 / 元空间 | Permanent Generation / Metaspace |
| 方法区 | Method Area |
| 代码缓存 | Code Cache |
| 即时编译 / 去优化 | Just-In-Time Compilation / Deoptimization |
| 运行时常量池 | Run-Time Constant Pool |
| 类加载器 / 双亲委派 | Classloader / Parent Delegation |
| 加载 / 链接 / 验证 / 准备 / 初始化 | Loading / Linking / Verification / Preparation / Initialization |
| 类数据共享 | Class Data Sharing (CDS) |
| 异常表 | Exception Table |
| 符号表 / 字符串表 / 驻留 | Symbol Table / String Table / Intern |
| 安全点 | Safepoint |
| 守护线程 | Daemon Thread |
10. 自己动手
1 | # 把上面四个 .java 文件下载到同一个目录,在该目录下执行 |