JVM 基础(二)
参考文献
- 大白话带你认识JVM - 掘金 (opens new window)
- 【JVM 极简教程】2 小时快速学会 JVM,史上用时最短,效率最高!bilibili (opens new window)
- 最重要的JVM参数总结 | JavaGuide (opens new window)
- JDK监控和故障处理工具总结 | JavaGuide (opens new window)
- JVM 线上问题排查和性能调优案例 | JavaGuide (opens new window)
# GC 垃圾回收
之前也提到,整个 JVM 包括类加载子系统、运行时数据区和执行引擎,其中执行引擎包括
- 解释器:翻译字节码到机器码的程序
- JIT 解释器:解释器的“缓存”,缓存高频字节码指令对应机器码
- 垃圾回收器:执行垃圾回收算法,在堆中进行 GC
垃圾回收是很重要的调优内容
# 垃圾回收机制
GC(Garbage Collection)
HotSpot VM 中的垃圾回收器以及适用场景
- HotSpot VM 是 Sun 用于 Java 平台的虚拟机,也是 JDK1.3 及之后所有 Sun JDK 的默认虚拟机,当然,由于甲骨文收购了 BEA 和 Sun,所以 HotSpot VM 现在是 Oracle 的,他同时还拥有 JRockit VM
垃圾回收 GC 分类
- Young GC / Minor GC:负责对新生代进行垃圾回收
- Old GC / Major GC:负责对老年代进行垃圾回收,目前只有 CMS 垃圾收集器会单独回收老年代,其他垃圾回收器都是在整堆回收的时候对老年代进行垃圾收集
- Full GC:整堆回收
为什么要垃圾回收?堆的内存有限,老的垃圾对象一直占着茅坑不拉屎,就会出现 OOM,回收是必要的
- 什么是垃圾:在 JVM 中没有任何引用指向他的对象
垃圾回收是为了解决内存泄露的问题?
# 垃圾标记
先进行垃圾标记,而后再进行回收
垃圾标记阶段:找到 JVM 中(主要是堆中)的垃圾对象,有以下两种方式
- 引用计数法
- 可达性分析法
引用计数法:每个对象维护一个计数器属性,记录当前对象被引用的次数
- 显然,实现很简单,当计数器为 0 时,为垃圾对象
- 缺点:需要额外空间和时间开销来存储引用计数;无法处理循环引用的问题
什么叫无法处理循环引用:例如 A 对象引用了 B,同时 B 对象引用了 A,如果采用引用计数,二者的计数器都为 1,将无法识别是否是垃圾(即使他们同时为垃圾对象),故而很少用这种方法来进行垃圾标记
可达性分析法(用的最多的标记法):以树状的方式,从 GC Root 根节点向下遍历,若可达,说明存在引用,否则则为垃圾对象
GC Roots 是一组引用,包括
- 虚拟机栈中执行的方法参数、局部变量对应的对象引用
- 本地方法栈中执行的方法参数、局部变量对应的对象引用
- 方法区中保存的类信息中的静态属性、常量属性对应的对象引用
对于每个 Root 而言,即从某个局部变量开始,将其作为根,开始遍历引用,如果所有的 Roots 都没遍历到对象 A,那么 A 被标记为垃圾对象
# 垃圾回收算法
标记-清除算法(Mark-Sweep):遍历标记可达对象,再遍历清除非可达对象
- 缺点:效率不高;会产生内存碎片
- 优点:思路简单
复制算法(Copying):每找到一个可达对象,将其复制到一块顺序的空闲内存块中,而后对原有的内存块整块删除
优点
- 效率较高:只需要遍历一次就可实现,当找到可达对象,就直接复制(在标记-清除中,要先遍历一次找到可达对象,而后再遍历一次删除掉不可达的对象)
- 无内存碎片
缺点
- 如果可达对象较多,会造成不必要的复制,降低性能 → 适合垃圾对象比较多的情况
- 需要修改栈帧中的引用地址
在新生代中,Eden 区、S0 区和 S1 区的流转就伴随这样的复制,因为在新生代,垃圾对象的比例是比较高的,这样的算法是合算的
标记-整理算法(Mark-Compact):双指针,在原地整理,就是一道移动零 (opens new window),将非零元素(可达对象)整理到数组前侧;但注意,标记整理算法不是边遍历边移动,而是先遍历遍历,再遍历移动,最后遍历清除
- 优点:无内存碎片;无需额外内存空间
- 缺点:效率低于标记清除,因为这一过程相当于标记-整理-清除;和复制算法一样,需要修改栈帧中的引用地址
| 总结 | 标记-清除 | 标记-整理 | 复制 |
|---|---|---|---|
| 时间效率 | O(2n) | O(3n) | O(n) |
| 空间开销 | O(1) | O(1) | O(n) |
| 内存碎片 | 有 | 无 | 无 |
| 移动对象(引用地址改变) | 否 | 是 | 是 |
# 分代收集算法
一种理念,而非具体的算法实现
几乎所有的垃圾收集器都是采用分代收集算法进行垃圾回收,这是由于新生代和老年代的对象性质决定的,新生代垃圾对象较多而老年代垃圾对象较少
即,垃圾对象的密度决定了不同垃圾回收算法的实施,例如,若垃圾对象很多,采用复制算法将会有较高收益,反之若可达对象很多,则复制算法将会造成不必要的开销,故而垃圾回收要分代处理
- 新生代中,采用复制算法
- 老年代中,不适合用复制算法,可以用标记-清除或标记-整理算法
- CMS 垃圾收集器采用的就是标记-清除算法
- Serial Old 垃圾收集器采用的是标记-整理算法
# Java 垃圾回收器
# 常见的垃圾回收器
| 回收器 | 串/并行 | 工作方式 | 适用区域 | 算法 | 备注 |
|---|---|---|---|---|---|
| Serial GC | 串行 | 工作线程暂停,一个线程进行垃圾回收 | 新生代 | 复制算法 | |
| Serial Old GC | 串行 | 工作线程暂停,一个线程进行垃圾回收 | 老年代 | 标记-整理 | |
| ParNew GC | 并行 | 工作线程暂停,多个线程进行垃圾回收 | 新生代 | 复制算法 | Serial GC 的多线程版 |
| CMS GC | 并行 | 用户线程和垃圾回收线程同时执行 | 老年代 | 标记-清除 | 低暂停 |
| Parallel GC | 并行 | 工作线程暂停,多个线程进行垃圾回收 | 新生代 | 复制算法 | 和 ParNew 相比,能动态调整内存分配情况,JDK8 默认 |
| Parallel Old GC | 并行 | 工作线程暂停,多个线程进行垃圾回收 | 老年代 | 标记-整理 | 替代串行的 Serial Old GC |
| G1 | 并行 | 用户线程和垃圾回收线程同时执行 | 整堆 | 分区算法 | 再延迟可控的情况下尽可能提高吞吐量,JDK9 默认 |
| ZGC | 并行 | 用户线程和垃圾回收线程同时执行 | 整堆 | 分页算法 | STW 的时间不超过 1ms,且不会随着堆的大小增加而增加 |
其中,Serial / Serial Old GC 是一组很老的回收器(复制 + 标记-整理)
- 出现时间很早
- 全部串行
- 可能在一些很老的 JDK8 项目会用到这样的垃圾回收
ParNew GC 和 CMS GC 是一个 GC 组合(复制 + 标记-清除)
- 并行回收
- 前者将暂停工作线程,而后者将同时进行用户线程和垃圾回收线程
同样的,Parallel / Parallel Old GC 也是一个 GC 组合(复制 + 标记-整理)
- 均为并行
- 二者都会暂停工作线程,而后进行多线程的垃圾回收
- 是 JDK8 的默认 GC
而最后的 G1 和 ZGC 都是整堆回收,分别采用分区算法和分页算法,前者(G1)为 JDK9 默认的 GC,并且在这一版本废弃了 CMS 回收器
垃圾回收器参数(在运行 JVM 时指定)
- -XX:+PrintCommandLineFlags,查看使用的垃圾收集器
- -XX:+UseSerialGC,指定使用 Serial GC 和 Serial Old GC
- -XX:+UseParNewGC,指定新生代使用 ParNew GC;+UseConcMarkSweepGC,指定老年代使用 CMS GC
- -XX:+UseParallelGC,指定新生代使用 Parallel GC;+UseParallelOldGC,指定老年代使用 Parallel Old GC(这两个配置一个,另一个自动激活)
可以发现,在分代回收中,新生代专用的垃圾回收器都是用的复制算法,老年代采用标记-整理或标记-清除算法,这和之前提到的算法性质的适用场景是保持一致的
# Serial 和 Parallel GC
读法:serial(siri)parallel(pie瑞乐)
Serial GC 和 Serial Old GC 都是串行 GC,在很早的 JDK 版本中有使用,他们在进行垃圾回收时
- 都会暂停工作线程,即 STW(Stop The World)
- 而后,开启一个线程(串行的含义在此),对各自的区域执行垃圾回收算法(复制算法 / 标记-整理算法)
因为当时的机器,一般只有一颗 CPU,所以设计的时候没有考虑那么多,一个线程就够了
Parallel GC 和 Parallel GC 像是 Serial 的多线程版本,他们同样会 STW,而后开启多个线程执行垃圾回收算法(复制算法 / 标记-整理算法)
- 为什么要 STW 的呢?如果边执行用户线程边回收会怎么样呢?答案是可能会造成垃圾对象的漏标和误删的情况
- 那为什么有的算法不需要 STW 呢?
# CMS 垃圾回收器
CMS 垃圾回收器在 Java 9 中已被标记为过时(deprecated),即废弃,在 Java 14 中被移除
针对老年代的垃圾回收器,其对应的新生代垃圾回收组合为 ParNew GC
CMS(ConcMarkSweep 并发标记清除),主要特点是“低暂停”,即 STW 的时间变短,这导致垃圾收集的过程更长了,但这似乎并不影响用户体验,因为用户并不感知垃圾回收,只觉得 STW 变短,我的任务执行得更快了,但实际上,程序的吞吐量更低了(单位时间内执行的用户线程变少了),因为垃圾回收的并发执行拖慢了程序
蓝色箭头为用户线程,黄色箭头为垃圾回收线程
- 初始标记阶段:只标记 GC Roots 下一层的可达对象,这个过程虽然会 STW,但很短
- 并发标记阶段:这是最耗时的一个阶段,会采用三色算法减少并发造成的垃圾对象的误判,但误差无法避免
- 重新标记阶段:修正并发标记阶段产生的误差,这需要 STW,但不是很长,这里会采用增量更新
- 并发清除阶段:删除垃圾对象(标记-清除算法),由于不需要移动对象位置,所以也可以和用户线程并发执行,不需要 STW
CMS 的问题
- 由于并发执行,有可能出现这样一种情况:老年代还没清理完毕,用户线程一直执行,产生的新对象又要进入老年代,而老年代没有足够的空间存放新来的对象,就会导致
concurrent mode failure,此时就会利用 Serial Old 来做一次垃圾清理,Serial Old 会做一次全局的 STW - 在并发清除阶段,可能会产生新的垃圾(因为之前可达,在这一阶段不可达了,断链了,此时垃圾对象就被错标为可达对象),称之为浮动垃圾,只能等到下一次 GC 时清理
- 采用的标记-清除算法会产生内存碎片,可通过参数
-XX: +UseCMSCompactAtFullCollection可以让 JVM 执行完标记-清除后在做一次整理,还可以通过-XX: CMSFullGCsBeforeCompaction来指定多少次清除后再做整理,默认为 0,即每次清除后都做整理
例如
-XX:+UseConcMarkSweepGC # 启用 CMS 收集器
-XX:+UseCMSCompactAtFullCollection # 允许 Full GC 时压缩
-XX:CMSFullGCsBeforeCompaction=2 # 每 2 次不压缩的 Full GC 后,执行 1 次带压缩的 Full GC
2
3
当然,高版本 JDK 中建议优先使用 G1 等现代收集器,避免依赖 CMS 的这些参数
# G1 垃圾回收器
Garbage-First GC
从 Java 9 开始,一直到 Java 25(2025 年 9 月发布),G1 一直都是 JDK 默认的垃圾回收器
- ZGC 从 Java 15 转正,但需手动指定
-XX: +UseZGC,适合低延迟大内存需求,但因兼容性和场景适应性,尚未替代 G1 的默认地位 - Shenandoah 在 Java 17 转正,和 ZGC 一样,都是低延迟 GC,需手动指定
-XX: +UseShenandoahGC,同样针对低延迟大内存的特定场景优化
G1 垃圾回收器会把堆空间划分成很多个 region,例如把堆内存平均分为 2048 个 region,仍然区分了 Eden 区、S0 区、S1 区和老年代,只不过各个区的空间可以是不连续的
另外,Humongous 区用于专门存放大对象(大对象指,大小超过一个 region 50% 的对象),也就是说,一个 H region 只存一个对象
在初始标记和最终标记都会进行 STW,至此和 CMS 大致相同,但下一阶段有着明显不同
- 在 ConcMarkSweep 中,二次标记后,会执行并发清除,即一边清除一边执行用户线程,这样会导致有浮动垃圾
- 而在 Garbage First 中,这一步回收将会 STW,这会避免浮动垃圾的产生,并且,这里是筛选回收
筛选回收阶段:通过-XX: MaxGCPauseMillis=?来指定 GC 的 STW 停顿时间,默认 200ms,也就是说,这里的筛选回收只会执行 200ms,很有可能并不会回收掉所有垃圾对象,他会通过一些算法来筛选一些性价比较高的回收对象先进行回收
并且,采用复制算法,不会产生内存碎片,他会把某个 region 里的垃圾对象复制到另外空闲的 region 中(例如相邻的 region)
G1 的分区算法
- YoungGC(复制算法):Eden 区满,触发 G1 的 YoungGC,对 Eden 区进行垃圾回收
- MixedGC(复制算法):当老年代的占用率达到了
-XX: InitiatingHeapOccupancyPercent=?指定的百分比,回收所有的新生代、部分的老年代以及大对象区 - FullGC(标记-整理算法):在进行 MixedGC 进行过程中,由于采用复制算法,如果复制过程中内存不够,则会触发 FullGC,会 STW,并采用单线程来进行标记-整理算法进行 GC,相当于用了一次 Serial GC
# ZGC 垃圾回收器
适合低延迟大内存的特定业务场景,例如金融交易、实时服务等
# 常用 JVM 参数
# 堆内存相关
# 堆内存大小
设置堆内存大小 (-Xms 和 -Xmx) (opens new window),根据应用程序的实际需求设置初始和最大堆内存大小,是性能调优中最常见的实践之一
推荐显式设置这两个参数,并且通常建议将它们设置为相同的值,以避免运行时堆内存的动态调整带来的性能开销,例如将 JVM 初始堆和最大堆都设置为 4GB
java -Xms4G -Xmx4G WebApplication.jar
# 新生代内存大小
设置新生代内存大小 (Young Generation) (opens new window),根据Oracle 官方文档 (opens new window),在堆总可用内存配置完成之后,第二大影响因素是为 Young Generation 在堆内存所占的比例
默认情况下,YG 的最小大小为 1310 MB,最大大小为无限制
1.通过-XX:NewSize和-XX:MaxNewSize指定
示例: 设置新生代最小 512MB,最大 1024MB
-XX:NewSize=512m -XX:MaxNewSize=1024m
2.通过-Xmn<young size>[unit]指定
示例: 将新生代大小固定为 512MB
-Xmn512m
GC 调优策略中很重要的一条经验总结是这样说的
尽量让新创建的对象在新生代分配内存并被回收,因为 Minor GC 的成本通常远低于 Full GC。通过分析 GC 日志,判断新生代空间分配是否合理。如果大量新对象过早进入老年代(Promotion),可以适当通过
-Xmn或 -XX:NewSize/-XX:MaxNewSize调整新生代大小,目标是最大限度地减少对象直接进入老年代的情况
另外,你还可以通过 -XX:NewRatio=<int> 参数来设置老年代与新生代(不含 Survivor 区)的内存大小比例
例如,-XX:NewRatio=2 (默认值)表示老年代 : 新生代 = 2 : 1。即新生代占整个堆大小的 1/3
-XX:NewRatio=2
# 元空间内存大小
JDK 7,在堆内存中存在永久代(PermGen),是比老年代更加顽固的对象存储区域,从 JDK 8 开始,永久代被移除,转而被元空间(Metaspace)代替,元空间使用本地内存,并不在堆内存中,同样存储顽固的老年对象
元空间的一些常用参数
-XX:MetaspaceSize=N #设置 Metaspace 的初始大小(是一个常见的误区,后面会解释)
-XX:MaxMetaspaceSize=N #设置 Metaspace 的最大大小
2
-XX:MetaspaceSize并非初始容量: Metaspace 的初始容量并不是-XX:MetaspaceSize设置,无论-XX:MetaspaceSize配置什么值,对于 64 位 JVM,元空间的初始容量通常是一个固定的较小值(Oracle 文档提到约 12MB 到 20MB 之间,实际观察约 20.8MB)扩容与 Full GC: 当 Metaspace 的使用量增长并首次达到
-XX:MetaspaceSize指定的阈值时,会触发一次 Full GC。在此之后,JVM 会动态调整这个触发 GC 的阈值。如果元空间继续增长,每次达到新的阈值需要扩容时,仍然可能触发 Full GC(具体行为与垃圾收集器和版本有关)
-XX:MaxMetaspaceSize的重要性:如果不显式设置-XX:MaxMetaspaceSize,元空间的最大大小理论上受限于可用的本地内存。在极端情况下(如类加载器泄漏导致不断加载类),这确实**可能耗尽大量本地内存。因此,强烈建议设置一个合理的-XX:MaxMetaspaceSize上限,以防止对系统造成影响
# 垃圾收集相关
垃圾回收器的选择
-XX: +UseSerialGC-XX: +UseParallelGC-XX: +UseConcMarkSweepGC(CMS 仅作用于老年代)-XX: +UseG1GC-XX: +UseZGC-XX: +UseShenandoahGC
日志打印,通过 Xlog 进行日志记录
-Xlog:[选择器][:[输出目标][:[日志格式][:[日志级别]]]]
GC 日志打印
java -Xlog:gc*=info:file=gc.log:time,level,tags -jar WebApplication.jar
gc*=info:所有 GC 相关日志(gc开头的标签),级别为infofile=gc.log:日志写入gc.log文件time,level,tags:每条日志包含时间戳、级别、标签(如gc,young)
# 处理 OOM
OOM,即 Out Of Memory 内存溢出
对于大型应用程序来说,面对内存不足错误是非常常见的,这反过来会导致应用程序崩溃。这是一个非常关键的场景,很难通过复制来解决这个问题
这就是为什么 JVM 提供了一些参数,这些参数将堆内存转储到一个物理文件中,以后可以用来查找泄漏
# 在发生 OOM 时生成堆转储文件 -XX:+HeapDumpOnOutOfMemoryError # 指定堆转储文件的输出路径。<pid> 会被替换为进程 ID -XX:HeapDumpPath=/path/to/heapdump/java_pid<pid>.hprof # 示例:-XX:HeapDumpPath=/data/dumps/ # (可选) 在发生 OOM 时执行指定的命令或脚本 # 例如,发送告警通知或尝试重启服务(需谨慎使用) # -XX:OnOutOfMemoryError="<command> <args>" # 示例:-XX:OnOutOfMemoryError="sh /path/to/notify.sh" # (可选) 启用 GC 开销限制检查 # 如果 GC 时间占总时间比例过高(默认 98%)且回收效果甚微(默认小于 2% 堆内存), # 会提前抛出 OOM,防止应用长时间卡死在 GC 中。 -XX:+UseGCOverheadLimit1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# JVM 测试及工具
JDK 版本:17
# JMH
Java Microbenchmark Harness,微观性能测试(适合测试 GC、内存分配、JIT 编译等参数的影响),由 OpenJDK 官方提供,专门用于编写 Java 基准测试,可精确控制测试条件,输出吞吐量、延迟等指标
编写测试类
import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
@Warmup(iterations = 3)
@Measurement(iterations = 5)
public class ObjectCreationBenchmark {
@Benchmark
public Object testObjectCreation() {
return new Object(); // 测试对象创建
}
public static void main(String[] args) throws Exception {
org.openjdk.jmh.Main.main(args);
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
测试不同垃圾回收器的表现
java -XX:+UseParallelGC -Xms512m -Xmx512m ObjectCreationBenchmark
java -XX:+UseG1GC -Xms512m -Xmx512m ObjectCreationBenchmark
java -XX:+UseZGC -Xms512m -Xmx512m ObjectCreationBenchmark
2
3
G1 GC 对中对象创建的表现
# JMH version: 1.36
# VM version: JDK 17, OpenJDK 64-Bit Server VM, 17+35-2724
# VM invoker: C:\Users\admin\northboat\jdk\jdk-17\bin\java.exe
# VM options: -javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2025.2.3\lib\idea_rt.jar=54768 -Dfile.encoding=UTF-8
# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable)
# Warmup: 3 iterations, 1 s each
# Measurement: 5 iterations, 1 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Throughput, ops/time
# Benchmark: com.jvmtest.ObjectCreationBenchmark.testMediumObject
# Run progress: 0.00% complete, ETA 00:02:00
# Fork: 1 of 5
# Warmup Iteration 1: 128506.889 ops/s
# Warmup Iteration 2: 231778.937 ops/s
# Warmup Iteration 3: 257013.084 ops/s
Iteration 1: 262015.261 ops/s
Iteration 2: 260963.205 ops/s
Iteration 3: 250278.083 ops/s
Iteration 4: 248514.132 ops/s
Iteration 5: 191932.289 ops/s
# Run progress: 6.67% complete, ETA 00:02:08
# Fork: 2 of 5
# Warmup Iteration 1: 165034.815 ops/s
# Warmup Iteration 2: 217845.377 ops/s
# Warmup Iteration 3: 209609.211 ops/s
Iteration 1: 113299.491 ops/s
Iteration 2: 177010.065 ops/s
Iteration 3: 197819.893 ops/s
Iteration 4: 247003.002 ops/s
Iteration 5: 252067.406 ops/s
# Run progress: 13.33% complete, ETA 00:01:59
# Fork: 3 of 5
# Warmup Iteration 1: 184069.545 ops/s
# Warmup Iteration 2: 229724.832 ops/s
# Warmup Iteration 3: 243329.659 ops/s
Iteration 1: 242141.510 ops/s
Iteration 2: 244614.468 ops/s
Iteration 3: 252281.770 ops/s
Iteration 4: 251600.053 ops/s
Iteration 5: 240344.243 ops/s
# Run progress: 20.00% complete, ETA 00:01:49
# Fork: 4 of 5
# Warmup Iteration 1: 185508.215 ops/s
# Warmup Iteration 2: 234360.919 ops/s
# Warmup Iteration 3: 253436.667 ops/s
Iteration 1: 241048.414 ops/s
Iteration 2: 252870.214 ops/s
Iteration 3: 215424.627 ops/s
Iteration 4: 220974.740 ops/s
Iteration 5: 233463.902 ops/s
# Run progress: 26.67% complete, ETA 00:01:40
# Fork: 5 of 5
# Warmup Iteration 1: 153859.383 ops/s
# Warmup Iteration 2: 229306.466 ops/s
# Warmup Iteration 3: 245920.780 ops/s
Iteration 1: 246542.282 ops/s
Iteration 2: 179722.105 ops/s
Iteration 3: 174140.572 ops/s
Iteration 4: 195903.161 ops/s
Iteration 5: 212587.147 ops/s
Result "com.jvmtest.ObjectCreationBenchmark.testMediumObject":
224182.481 ±(99.9%) 27072.846 ops/s [Average]
(min, avg, max) = (113299.491, 224182.481, 262015.261), stdev = 36141.475
CI (99.9%): [197109.635, 251255.328] (assumes normal distribution)
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
G1 GC 三种对象创建测试的统计
Benchmark Mode Cnt Score Error Units
ObjectCreationBenchmark.testMediumObject thrpt 25 224182.481 ± 27072.846 ops/s
ObjectCreationBenchmark.testPlainObject thrpt 25 514603949.340 ± 37591131.483 ops/s
ObjectCreationBenchmark.testSmallObject thrpt 25 12206739.477 ± 977756.319 ops/s
2
3
4
关注输出中的Ops/s(每秒操作数),数值越高表示性能越好
通过对比不同 GC 收集器的结果,可观察
- ZGC 在大对象创建时是否延迟更低?
- G1 的
MaxGCPauseMillis参数是否会影响吞吐量?
# gc-stress-test
一个简单的 Java 程序,通过循环创建大量对象(可控制对象大小和存活率),强制触发 GC,专门测试 GC 行为(适合调试 GC 参数、观察内存碎片、GC 日志等)
测试类
public class GCStressTest {
public static void main(String[] args) throws InterruptedException {
while (true) {
// 创建一批对象(部分存活,部分垃圾)
Object[] garbage = new Object[1000];
for (int i = 0; i < garbage.length; i++) {
garbage[i] = i % 10 == 0 ? new byte[1024 * 10] : null; // 10%存活率
}
Thread.sleep(10); // 控制创建频率
}
}
}
2
3
4
5
6
7
8
9
10
11
12
maven package 后 class 文件生成在target/classes/com/jvmtest/GCStressTest.class
执行命令
cd C:\Users\admin\Desktop\Repo\JVMTest\target\classes
java -Xms1g -Xmx1g -XX:+UseG1GC -Xlog:gc*=info:file=g1_gc.log:time,level,tags com.jvmtest.GCStressTest
2
切换为 Parallel GC
java -Xms1g -Xmx1g -XX:+UseParallelGC -Xlog:gc*=info:file=paralle_gc.log:time,level,tags com.jvmtest.GCStressTest
切换为 ZGC
java -Xms1g -Xmx1g -XX:+UseZGC -Xlog:gc*=info:file=z_gc.log:time,level,tags com.jvmtest.GCStressTest
这条命令参数将在当前目录下生成xx_gc.log
# JConsole
JConsole 是基于 JMX 的可视化监视、管理工具,可以很方便的监视本地及远程服务器的 java 进程的内存使用情况
你可以在控制台输入
jconsole命令启动或者在 JDK 目录下的 bin 目录找到jconsole.exe然后双击启动
JVM线上问题排查和性能调优案例 | JavaGuide (opens new window)
# 各版本 JDK 特性
参见 New Features | JavaGuide (opens new window)
- record
...入参- var
- 虚拟线程
# Java 8
主要改动
- 接口 interface 在这一版本被引入
- Lambda 表达式被引入,使代码更紧凑(流式编程),并且支持简单的函数式编程
- 引入流类型 stream,可以流式操纵 Collection 数据
- 在 Java 8 中,改动了 HashMap 的底层实现数据结构,从
链表数组改为链表/红黑树数组,数组中存放头节点/根节点,通过 hash 算法找到数组下标再插入(链表长度超过 8 则转换为红黑树,红黑树节点少于 6 则转换为链表) - 引入 Optional 类,更优雅的处理 NPE(NullPointerException)
# Java 9
主要改动
- G1 成为默认垃圾回收器,在 Java 8,默认 GC 是 Parallel / Parallel Old GC,并且在 Java 9,CMS 回收器被废弃
- String 的存储结构优化:从
char[]存储变为byte[]存储,节省了空间 - 变量句柄