夜雨聆风学习资料网

ARTICLE · 1380268

JVM 全景:从源码到机器码

JVM 全景:从源码到机器码

应用层的问题追到底,一半的尽头是 JVM。这个系列计划:全景、内存布局、GC 基础、G1、ZGC、内存分配与逃逸分析、类加载与字节码、JIT、诊断工具链、生产实战。第一篇:JVM 到底是什么,一条 Java 指令从源码到机器码要经过什么,以及三个新手期最容易踩的坑——它们恰恰是生产环境里最贵的三种事故。

本篇三条主线:① JVM 是「规范—实现—运行时实例」三层,讨论问题时先分清在说哪层;② 一条指令的完整旅程:编译 → 类加载 → 解释 → JIT → GC 全链路;③ 三个事故都是「认知边界」事故——不是不会调参,是不知道 JVM 的账本不止一个。

事故一:升级 JDK 17 后线上 P99 抖动。一次大版本升级,发布后前 40 分钟接口 P99 从 12ms 抖到 200ms,随后恢复。回滚后复现,升级前从未出现。原因:新环境的 C2 编译队列冷启动,热点方法重新 Profiling 和编译,期间大量请求走在解释执行路径上。止血靠发布后预热压流量,根治靠把「JIT 预热」写进发布流程——JVM 的性能不是常量,启动后有一段爬坡期,流量必须配合这个爬坡期。

事故二:NoSuchMethodError 在深夜爆发。一个依赖升级后本地全绿、测试全绿,上线两小时后同一接口偶发 NoSuchMethodError。根因:两个依赖各自传递引入了同一 artifact 的不同版本,Maven 仲裁选了旧版,而新代码路径在特定分支才会调用到缺失的方法——类路径上「谁说了算」不搞清楚,任何测试都保证不了运行时的类长什么样。

事故三:Xmx 设了 2g,容器还是被杀。Pod 内存 limit 3g,JVM -Xmx2g,运维以为留了 1g 余量很稳。结果大促期间连续 OOMKilled。根因:堆外还有 Metaspace、直接内存、线程栈、GC 自身开销,峰值合计超过 1g——-Xmx 只管堆。进程内存的账本至少有四本,少看一本就会在容器里被内核杀掉。

一、技术分析:立起 JVM 的骨架

1.1 先分清三层:规范、实现、实例

说「JVM」的时候其实可能在说三样东西。JVM 规范是一份文档(The Java Virtual Machine Specification),定义了字节码格式、指令集、类文件结构、内存模型——它只规定「必须表现成什么样」,不规定怎么实现;JVM 实现是按规范写的软件,HotSpot 是事实标准,此外还有 OpenJ9、GraalVM 等;JVM 运行时实例是你 java 命令启动的那个进程。面试里说「JVM 方法区在哪」答 PermGen 或 Metaspace 都不算错——规范只说方法区是逻辑概念,放在哪是实现的事:HotSpot 8 之前用 PermGen,8 之后移到 Metaspace。分不清这三层,很多争论根本无法展开。

1.2 一条指令的旅程:从源码到机器码

把一条 Java 指令的一生展开(图 1):javac 把源码编译成 .class 字节码——注意 javac 是编译到字节码,不是编译到机器码,它只是 JVM 的前置工具,不是 JVM 的一部分;类加载子系统把字节码读进来、校验、变成方法区的运行时结构;main() 入口之后,执行引擎接管——解释器逐条解释字节码,热点代码被 JIT 编译成机器码;整个过程中对象在堆上分配,GC 持续工作。编译期一次完成,运行期持续发生——这是 Java「一次编写、到处运行」的机制根源,也是 Java 性能问题和 C++ 性能问题形态完全不同的原因:C++ 的性能在编译时就定死,Java 的性能是运行时演化的。

图 1 · 一条 Java 指令的完整旅程:编译期一次完成,运行期持续发生

1.3 体系结构:三大子系统与一根桥

JVM 的内部结构可以压缩成三块(图 2):类加载子系统负责把字节码变成可执行的运行时结构;运行时数据区是内存的账本,堆和 Metaspace 线程共享,虚拟机栈、程序计数器、本地方法栈线程私有,此外还有一块容易漏的直接内存——NIO 的 DirectByteBuffer 用它,它不受 Xmx 管;执行引擎包含解释器、JIT 编译器和 GC——注意 GC 是执行引擎的一部分而不是独立模块,它和内存分配深度耦合。三块之间靠 JNI 这根桥连接本地世界。后面九篇的内容全部挂在这三块上:内存布局(02 篇)展开第二块,GC 系列(03-06 篇)展开执行引擎,类加载(07 篇)展开第一块。

图 2 · JVM 体系结构:类加载子系统 → 运行时数据区 → 执行引擎,JNI 连接本地世界

1.4 类加载五阶段与「活过来」的那一刻

类加载的流水线(图 3)分五步:加载、验证、准备、解析、初始化。前三步纯 JVM 内部动作:加载读字节流生成 Class 对象,验证防恶意字节码,准备给静态变量分配并设零值——int a = 1 在准备阶段 a 是 0,真正变成 1 要等初始化阶段(final 常量除外,它在准备阶段就赋值);解析把常量池的符号引用换成直接引用,可以延迟;初始化是第一个执行 Java 代码的阶段,它执行静态变量赋值和静态块(合称 <clinit>)。什么时候初始化?六种主动引用:new、读写静态字段(非常量)、反射调用、调用 main 的主类、初始化子类时父类先初始化、以及 JDK 7 的动态语言支持。其余都是被动引用,不触发——「类什么时候加载」和「类什么时候初始化」是两个问题,生产事故里很多诡异的 NPE 和常量缓存问题就出在这。

图 3 · 类加载五阶段:前四步 JVM 主导,初始化是第一个带 Java 语义的阶段

1.5 双亲委派:先问爸爸,再自己干

类加载器的层次(图 4)从上到下:Bootstrap(核心类库)、Platform(9+ 的平台类库,8 里叫 Extension)、Application(classpath)、自定义加载器。双亲委派的规则只有一句话:收到加载请求先委托父加载器,父加载器反馈无法完成时子加载器才自己加载。它解决两个问题:安全(你自己写个 java.lang.String 加载不进来,核心类永远由顶层说了算)和唯一(核心类全 JVM 只加载一次)。但它不是不能打破:SPI 用 ContextClassLoader 反向委托、Tomcat 每个应用独立加载器做隔离、热部署框架故意重复加载——打破的代价都要自己承担。还有一个必须刻进脑子的事实:类的同一性由「加载器 + 全限定名」共同决定,两个加载器加载同一个类,instanceof 会返回 false。事故二里深夜爆发的类型转换异常,根子都在这。

图 4 · 双亲委派模型:委派向上、失败向下,打破它有代价

1.6 执行引擎:解释器打底,分层编译升级

为什么不启动时就把所有代码编译成机器码?因为编译本身有成本,而且大部分代码根本跑不了几次。分层编译(图 5)的思路是按热度区别对待:Tier 0 解释执行保冷启动;Tier 1-3 是 C1(客户端编译器)快速编译并采集 Profiling 数据;Tier 4 交给 C2(服务端编译器)做激进优化——内联、逃逸分析、循环优化都在这层。热点探测靠方法调用计数和回边计数,默认阈值约一万次。关键机制是去优化:C2 的激进优化建立在Profiling 猜想上(比如「这个字段只会是 A 类」),猜想一旦被证伪,机器码作废退回解释器重新走流程——JIT 不是一次到位,是持续修正。事故一的 P99 爬坡正是这条流水线的冷启动成本:全部热点要重新走Tier 0 → 3 → 4,大服务的爬坡期可以长达几十分钟。

图 5 · 分层编译五层:C1 保启动、C2 保峰值,去优化持续修正猜想

1.7 内存账本不止一本:Xmx 之外还有三本

事故三的根因值得单独展开。一个 JVM 进程的内存至少四本账:堆(-Xmx 管,最大头);Metaspace(类元数据,-XX:MaxMetaspaceSize 管,动态生成类的场景会失控);线程栈(每个线程一份,-Xss 默认 1M,线程数 × 1M 不是小数);直接内存(NIO 和 Netty 用,-XX:MaxDirectMemorySize 管,默认约等于 Xmx)。容器时代这三本账全都致命:堆设得刚好等于容器 limit,堆外一涨就被内核 OOMKilled,而且 kill 发生在内核层,JVM 的 HeapDumpOnOutOfMemoryError 完全抓不到现场——因为它压根不知道自己要死了。这是本系列反复出现的主题:先知道账本有哪些,再谈怎么管。02 篇会把四本账逐一展开。

二、生产实战:一份参数与一套流程

2.1 配置一:生产 JVM 启动参数全量

这份参数是后面各篇的收敛预览:GC 参数(03-06 篇)、JIT 参数(08 篇)、诊断参数(09 篇)各自的细节后面展开,这里先给骨架。每个参数后面标注它保护什么——看不懂保护什么的参数不要抄:

# ==== 生产 JVM 启动参数骨架(JDK 17)====
# --- 堆:起始=最大,避免运行期扩缩容抖动 ---
-Xms4g -Xmx4g
# 等值原则:动态扩容会产生 Full GC 风暴
# --- 元空间:给动态生成类留上限 ---
-XX:MetaspaceSize=256m
-XX:MaxMetaspaceSize=512m
# --- 线程栈:默认 1M,千线程服务注意乘积 ---
-Xss1m
# --- GC:G1 起步(04 篇细讲)---
-XX:+UseG1GC
-XX:MaxGCPauseMillis=50
# --- JIT:默认分层编译,不用动 ---
-XX:+TieredCompilation
# --- 诊断:OOM 留现场 ---
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/data/dump/
# OOM 时先 dump 再退出,配合告警抓盘
-Xlog:gc*:file=/data/logs/gc.log:time,uptime:
    level,tags:filecount=5,filesize=50m
# 统一日志:可观测性是排障的底线

2.2 配置二:容器环境的正确姿势

容器里不要手写 -Xmx,让 JVM 感知容器 limit 并自己算堆大小;同时用 NativeMemoryTracking 把堆外账本亮出来:

# ==== 容器参数(limit: 4Gi 的 Pod)====
# 按 limit 百分比分堆,留 30% 给堆外
-XX:MaxRAMPercentage=70.0
# 4Gi x 70% = 堆约 2.8G
# 余量给元空间/栈/直接内存
# 打开内存追踪(生产可用,开销约 5%)
-XX:NativeMemoryTracking=summary
# 容器里禁用手动 bias/显式 GC 等历史包袱
-XX:-UsePerfData 保留;去掉 UseCompressedOops
# 现代默认开启,不要再写

# 体检命令:进程内存的四本账
jcmd 1 VM.native_memory summary
# 输出示意(单位 KB):
#   Java Heap:    2936012   <- Xmx 那本
#   Class:          98304   <- Metaspace
#   Thread:         61440   <- 60 线程 x 1M
#   Internal:       20480   <- GC 自身等
#   Total: committed ≈ 3.1G < limit 4G  安全

配额上还有一条纪律:Pod 的 requests 和 limit 都要按「native_memory summary 的 Total」来定,不是按 Xmx。总 committed 加上安全余量(建议 20%)就是 limit 的下限。上线前跑一轮压测看 summary 曲线,四本账各自的峰值记进容量表——这套动作和 Kafka 篇的容量规划是同一个思想:可计算,不拍脑袋。

2.3 复盘:JDK 17 升级的三周

回到事故一。复盘时把升级流程固化成五步:① 依赖先行——把依赖矩阵在 JDK 17 下全量编译,处理 remove 掉的 API(尤其 sun.misc 和 JEE 模块);② GC 换代验证——17 默认 G1,与 8 的 Parallel 对比压测,不能想当然更快;③ JIT 预热方案——发布后灰度实例先压 10 分钟流量再接真流量,或用预热框架提前触发热点方法;④ 灰度观测——至少 10% 流量观察 24 小时,盯 P99 和 GC 日志两个口径;⑤ 回滚预案——镜像双版本并存,一条命令切回。三周的升级成本里,真正的难点从来不是编译报错,而是行为差异:字符串去重、JIT 优化策略、默认 GC 都变了,压测口径必须覆盖。

2.4 类冲突排查 SOP:从报错到根因十分钟

事故二这类问题有一套标准动作。第一步定性:NoSuchMethodError 是「类在、方法不在」——版本旧了;NoClassDefFoundError 是「运行期找不到类」——编译期在、运行期不在,scope 配置问题;ClassNotFoundException 是「主动加载找不到」——反射或 SPI 配置问题。三种错三个方向,先分清再动手。第二步定位:报错栈里的类是谁加载的:

# 第一步:报错时先看类从哪个 jar 加载
# (arthas,09 篇细讲)
sc -d com.google.common.collect.Lists
# 输出 class-info 里的 jar 位置即真相

# 第二步:本地复现依赖仲裁
mvn dependency:tree -Dverbose
# 找到目标 artifact 的两条路径
#   +- A:1.0 -> guava:20.0 (omitted for
#      conflict with 31.0)
# omitted 标记的就是被仲裁掉的版本

# 第三步:显式锁定版本
<dependencyManagement>
  <dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.0-jre</version>
  </dependency>
</dependencyManagement>

SOP 的最后一步是固化:CI 里加 maven-enforcer-plugin 的dependencyConvergence 规则,让仲裁冲突在提交时就报错——把「深夜爆发的 NoSuchMethodError」变成「提交时的红线」,和 Kafka 篇把事故变成上线卡点是同一个方法:事故会重复,卡点不会。

三、核心源码:四段看懂骨架

3.1 ClassLoader.loadClass:双亲委派的骨架

protected Class<?> loadClass(String name,
    boolean resolve)
    throws ClassNotFoundException {
  synchronized (getClassLoadingLock(name)) {
    // 1. 先查:这个加载器是否已加载过
    Class<?> c = findLoadedClass(name);
    if (c == null) {
      try {
        // 2. 有父加载器就委托父加载器
        if (parent != null) {
          c = parent.loadClass(name, false);
        } else {
          // 3. 无父(Bootstrap)查核心类库
          c = findBootstrapClassOrNull(name);
        }
      } catch (ClassNotFoundException e) {
        // 父加载器加载不了,抛回这里
      }
      if (c == null) {
        // 4. 委派失败,本加载器亲自查找
        c = findClass(name);
      }
    }
    if (resolve) resolveClass(c);
    return c;
  }
}

四步结构就是双亲委派的全部:查缓存 → 委托父 → 委派失败则 findClass。自定义加载器应该重写 findClass 而不是 loadClass——重写 loadClass 就把委派链改掉了,除非你明确要打破它。

3.2 URLClassLoader.findClass:委派失败后的亲自查找

// 委派到不了这里,能进来就说明
// 父加载器都加载不了
protected Class<?> findClass(String name) {
  // 1. 把全限定名变成资源路径
  String path =
      name.replace('.', '/') + ".class";
  Resource res = ucp.getResource(path, false);
  if (res != null) {
    // 2. defineClass:字节流 -> Class 对象
    //    (期间触发验证与准备)
    return defineClass(name, res);
  }
  throw new ClassNotFoundException(name);
}

findClass 的两步把「加载」阶段写实了:定位字节流,然后 defineClass 进入 JVM 内部——验证和准备都在 defineClass 的调用链里完成。自定义类加载器的扩展点就是这里:从网络读、从加密文件读、从内存生成,都在 findClass 里换字节流来源。

3.3 Class.forName 与加载器初探:主动初始化的入口

// 反射触发的就是六种主动引用之一
public static Class<?> forName(
    String className)
    throws ClassNotFoundException {
  // caller sensitivity:取调用者的加载器
  Class<?> caller =
      Reflection.getCallerClass();
  // initialize=true 是关键差异:
  // 它会一路执行到 <clinit>
  return forName0(className, true,
      ClassLoader.getClassLoader(caller),
      caller);
}

// 对比:加载但「不活过来」
Class<?> c = Loader.class.getClassLoader()
    .loadClass("com.demo.Loader");
// 此时 c 非 null,但静态块没跑过
// 第一次 new / 读静态字段时才触发 <clinit>

forName 和 loadClass 的区别是面试高频题:前者「加载 + 连接 + 初始化」,后者只「加载」。JDBC 驱动注册、SPI 加载都用 forName——因为驱动注册逻辑写在静态块里,不初始化等于没装。

3.4 分层编译的热点判定(HotSpot 简化)

// HotSpot C++ 侧的判定逻辑(简化伪码)
bool should_compile(Method* m,
    CompLevel cur) {
  int invocations = m->invocation_count();
  int backedges   = m->backedge_count();
  switch (cur) {
  case CompLevel_none:        // Tier 0
    // 达到阈值 -> 先进 C1(Tier 3 采数据)
    return invocations >= INV_THRESHOLD;
  case CompLevel_c1_profile:  // Tier 3
    // Profiling 数据成熟 -> 提交 C2
    return invocations >= C2_THRESHOLD
        && profile_mature(m);
  }
  return false;
}
// C2 猜想被打破 -> deoptimize 退回解释器
// 该方法计数清零,重新积累热度

这段伪码解释了两件事:为什么启动后有一段爬坡期(每个热点都要从解释器重新爬梯子),以及为什么预热压测是升级流程的必选项。08 篇会把去优化和逃逸分析展开到字节码层面。

四、七笔账

启动账:大服务冷启动的爬坡期 20~40 分钟,期间解释执行路径的性能只有编译后的一半以下。没有预热就接全量流量,等于上线即降级。

依赖账:一个中型服务的 classpath 上平均 200+ 个 artifact,冲突靠仲裁「碰巧能用」是常态。enforcer 红线的成本是配置一次,收益是消灭一类深夜事故。

内存账:Xmx 只是最大的一本账,不是全部。容器 limit 按 native_memory summary 的 Total 定,余量 20% 起——少留的那 20% 会变成凌晨的 OOMKilled 告警。

兼容账:JDK 大版本升级的成本分布:编码适配 30%、依赖适配 30%、行为差异验证 40%。行为差异最贵也最容易漏——GC 换代、JIT 策略、默认值变化都在这一类。

排障账:三种 NoClassDef 类报错平均排障 2 小时,方向错了拖到 2 天。先定性(三个错误三个方向)再用 arthas 定位,10 分钟内结束战斗。

性能账:分层编译让峰值性能比纯解释快 10~30 倍,但 Profiling 本身有5~10% 开销。绝大多数服务不该关分层编译,除非你是短命 CLI 工具。

心智账:「规范—实现—实例」三层分清后再看所有争论:PermGen vs Metaspace 是实现差异,方法区是规范概念。争论先对齐层面,否则鸡同鸭讲。

五、高频面试题(含答案)

Q1 · JVM 是规范、软件还是进程?HotSpot 又是什么?

三者都是,分三层回答:JVM 规范是文档(定义字节码、指令集、内存模型);HotSpot 是规范的主流实现(OpenJDK/JDK 默认虚拟机,因热点探测而得名);java 命令启动的进程是一个 JVM 实例。讨论「方法区在哪」时,规范只定义逻辑概念,存放位置是实现细节。

Q2 · javac 属于 JVM 吗?字节码和机器码的区别?

javac 不属于 JVM,它是把源码编译成字节码的前置编译器(本身是 Java 程序)。字节码是面向虚拟机的中间表示、平台无关;机器码面向具体 CPU 架构。字节码由 JVM 执行时再通过解释器/JIT 转成机器码,这就是「一次编写到处运行」的机制。

Q3 · 类加载五个阶段的顺序可以打乱吗?哪个阶段最特殊?

加载、验证、准备、解析的顺序相对固定(解析支持延迟),初始化必须在准备之后且第一个执行 Java 代码。最特殊的是初始化:它由六种主动引用触发,其余被动引用不触发——这是「类加载了但没活过来」的根源。

Q4 · 静态变量在准备阶段是什么值?final 常量呢?

准备阶段静态变量一律零值(int=0、引用=null),int a=1 的 1 要到初始化阶段才赋值;static final 的编译期常量(String、基本类型字面量)在准备阶段直接赋值,因为它们进了常量池,不需要 <clinit> 参与。

Q5 · 六种主动引用是什么?各举一例被动引用。

主动:new 实例化;读写非编译期常量的静态字段;反射 Class.forName;启动主类;初始化子类先触发父类;JDK 7 动态语言句柄。被动示例:通过子类引用父类静态字段只触发父类、定义数组Foo[] arr 不触发 Foo、访问 static final 常量不触发。

Q6 · 双亲委派的流程和设计动机?

收到加载请求先委托父加载器逐级向上,父级无法完成才自己 findClass。动机:安全——用户伪造 java.lang.String 加不进来;唯一——核心类全局只加载一份。实现就是 loadClass 四步:查缓存、委托、兜底、findClass。

Q7 · 怎么打破双亲委派?代价是什么?

重写 loadClass 改委派逻辑,或用线程上下文加载器反向委托(SPI/JDBC);Tomcat 为每个 webapp 建独立加载器先自己加载实现隔离;OSGi 用网状委派。代价:类的唯一性靠约定维护、隔离边界出问题排查困难、热部署泄漏风险。

Q8 · Tomcat 为什么要自定义类加载器?

两个诉求:隔离——两个应用用不同版本的同一个库,必须各自加载各自的;卸载——应用重新部署时丢弃其加载器,连带卸载所有类,否则 Metaspace 只涨不降。WebappClassLoader 故意先自己加载(违背委派)再委托父级。

Q9 · 两个不同的加载器加载同一个类,instanceof 结果?

false。类的同一性由「Class 对象 = 加载器 + 全限定名」决定,两个加载器加载的同一个类名是两个不同的 Class,相互赋值会抛 ClassCastException。这是自定义加载器隔离场景最常见的坑。

Q10 · 解释器和 JIT 为什么共存?只留 JIT 不行吗?

JIT 编译有成本(编译线程、代码缓存),且多数代码只执行一两次,编译它们纯亏;解释器启动零成本。共存 = 分层编译:解释保冷启动,热点才值得编译。只留 JIT(如 AOT 化)会让启动时间和内存暴涨。

Q11 · C1 和 C2 的定位差异?

C1 快编译、轻优化、必带 Profiling 采数据;C2 慢编译、激进优化(内联、逃逸分析、向量化),依赖 C1 采集的 Profiling 数据做猜想。分层编译让 C1 管启动和过渡(Tier 1-3),C2 管峰值(Tier 4)。

Q12 · 热点怎么探测?相关的两个 JVM 参数?

方法调用计数 + 回边计数(循环),之和超阈值触发编译。-XX:CompileThreshold 控制方法阈值(分层编译下是内部阈值,不可直接设)、OnStackReplacePercentage 控制回边。热度还带衰减(半衰期),长时间不调用的方法计数会退火。

Q13 · 什么是去优化?举一个必然发生的场景。

C2 基于 Profiling 猜想编译(如「此字段只会是 A 类」),运行时出现违例即猜想证伪,机器码作废、退回解释器重新采集。必然场景:首次向原本单态的集合传入另一个类型;或类层次被子类加载器扩展后。去优化不是 bug,是分层编译的自我修正。

Q14 · -Xmx2g 的进程在容器 limit 3g 里安全吗?

不安全。除堆外还有 Metaspace(动态类生成可达数百 MB)、线程栈(线程数 x -Xss)、直接内存(默认约等于 Xmx)、GC 自身开销、Code Cache。四本账峰值加起来超过 limit 就被内核 OOMKilled,且 JVM 无感知、抓不到 dump。正确姿势 MaxRAMPercentage + native_memory summary 实测。

Q15 · Metaspace 和 PermGen 的区别?为什么要移除?

PermGen 在堆内、大小固定易 OOM(类加载器卸载不彻底时);Metaspace 在本地内存、默认只受物理内存限制(可用 MaxMetaspaceSize 封顶)。移除动机:PermGen OOM 是历史高频故障,移到本地内存后与堆生命周期解耦,为 GC 演进扫清障碍。

Q16 · 直接内存是什么?和堆的区别?怎么限制?

堆外本地内存,NIO DirectByteBuffer 使用,Netty 大量依赖。区别:不受 GC 管理(靠 Cleaner 回收)、分配释放贵但 IO 零拷贝快。-XX:MaxDirectMemorySize 封顶,默认约等于 -Xmx。排查它用 native_memory summary 和 NMT 的 Other 章节。

Q17 · 线程栈大小谁定?1000 线程的服务栈内存多大?

-Xss 默认 1M(64 位 Linux)。1000 线程理论 1G——注意这是committed 虚拟内存按需提交,实际物理占用看栈深,但容量的规划要按 committed 算。深递归场景调大 -Xss,海量线程场景调小到 256k~512k。

Q18 · JNI 调用的开销在哪里?什么场景该避免?

开销在:Java→native 的边界切换(保存寄存器现场)、句柄管理、数据拷贝(数组传递)。频繁跨界的循环内调用要批量化。JDK 9 后有 Foreign 链路(Panama)大幅降低开销,新代码优先考虑。

Q19 · 容器里配 JVM 参数的正确姿势?

不要手写 -Xmx 固定值,用 -XX:MaxRAMPercentage=70 让 JVM 按容器 limit 计算(JDK 8u191+/10+ 默认容器感知);开 NativeMemoryTracking 验证总 committed 占 limit 的 80% 以内;CPU 用 -XX:ActiveProcessorCount 显式指定,避免感知错核数。

Q20 · OOM 时怎么自动留现场?这个参数的局限?

-XX:+HeapDumpOnOutOfMemoryError + HeapDumpPath。局限:只覆盖堆内 OOM——Metaspace OOM 早期版本部分覆盖、直接内存 OOM 和容器 OOMKilled 完全不触发(kill 的是内核)。完整方案 = 堆 dump + NMT 监控 + 容器内存告警三层。

六、一页速记

JVM 全景六句:① 规范、实现、实例分三层,争论先对齐层面;② 编译期一次完成,运行期持续演化——JVM 的性能是活物;③ 类加载五阶段,初始化是「活过来」的那一刻,六种主动引用触发;④ 双亲委派一句话:先问爸爸,爸爸不行自己干;打破要付代价;⑤ 分层编译:解释打底、C1 采证、C2 决战、去优化纠错;⑥ 内存四本账:堆、Metaspace、线程栈、直接内存,Xmx 只管一本。

七、小结与下篇预告

整个系列的骨架:三大子系统(类加载、运行时数据区、执行引擎)+ 四本内存账 + 一条「源码到机器码」的完整链路。三个开场事故分别对应三块骨架的盲区:不了解 JIT 演化(事故一)、不了解类加载与委派(事故二)、不了解内存账本(事故三)。后面的每一篇都在这块骨架上长肌肉:02 篇拆运行时数据区,把四本账的布局、对象在内存里长什么样、以及 OOM 的每种形态讲透——它是 GC 系列(03-06)的地基,也是排障工具链(09 篇)的地图。

建议:拿你手头的服务跑一遍 jcmd 1 VM.native_memory summary,把四本账的实际占比记下来——这个数字后面每一篇都会用到,JVM 的学习从看清自己的进程开始。

回首页,搜索你想要的文档

在首页搜索框输入关键词,快速定位资料

文库首页搜索指引 立即搜索

相关学习资料