java ee--jvm

本文系统讲解JVM的四大核心子系统:运行时数据区(堆、栈、方法区等内存布局)、类加载机制(五阶段与双亲委派模型)、垃圾回收(可达性分析、分代算法、主流收集器如CMS/G1)以及Java内存模型(JMM)的主内存/工作内存、happens-before规则与volatile语义。以HotSpot为基准,强调规范与实现差异、内存异常(OOM/StackOverflow)定位方法,并揭示JVM作为定制化虚拟机的设计哲学。

深入理解 JVM:一台"被定制出来的计算机"是如何运转的

为什么我们要懂 JVM

如果只用一句话概括 Java 的灵魂,我会说:Java 的"一次编写、到处运行",从来不是 Java 语言的功劳,而是 JVM 的功劳。 我们写的 .java 文件,编译器并不会把它翻译成某个具体操作系统的机器码,而是翻译成一套与平台无关的"字节码"。真正把这套字节码"喂"给不同 CPU、不同操作系统、并把它们跑起来的,是 JVM 这台虚拟出来的计算机。

也正因如此,JVM 是横在每个 Java 工程师面前的一道分水岭:面试时它高频出现(内存分区、垃圾回收、类加载、volatile),工作中它无处不在(内存溢出排查、GC 调优、并发可见性 Bug)。很多人学 JVM 学得很痛苦,是因为一上来就陷进了"堆、栈、方法区、双亲委派"这些名词里,却不知道这些区域为什么必须存在。

这篇文章我想做一件事:把 JVM 当成一台真实的计算机来讲,先建立全局图景(总),再逐层拆解它的内存、类加载、垃圾回收、并发内存模型四大子系统(分),最后再把它们串起来,谈谈我自己的理解(总)。我会尽量把课程里的每一个要点讲透,并对原文里一些容易误导、甚至明显写错的表述做纠正和补充。

全文默认以 Oracle JDK 的 HotSpot 虚拟机为前提展开——这是现实中绝大多数人真正在用的那一个。


第一部分(总览篇):JVM 到底是什么,它从哪来

1.1 一台"现实当中不存在的计算机"

JVM 全称 Java Virtual Machine(Java 虚拟机)。虚拟机的定义是:通过软件模拟的、具有完整硬件功能的、运行在一个完全隔离环境中的完整计算机系统。 换句话说,JVM 本质上就是一段程序,它在自己内部"假装"自己是一台完整的计算机——有自己的 CPU(执行引擎)、内存(运行时数据区)、指令集(字节码指令)。

很多人会把 JVM 和 VMware、VirtualBox 这类虚拟机混为一谈,其实它们有本质区别,这一点原文写得比较模糊,我帮你厘清:

  • VMware / VirtualBox 这类虚拟机,是用软件模拟物理 CPU 的指令集。它们会忠实还原真实 CPU 里那一整套寄存器,所以能跑任意操作系统、任意语言写出来的程序,代价是"重"。
  • JVM 则是用软件模拟 Java 字节码的指令集。它不需要还原真实 CPU,所以做了一个大胆的"裁剪"——它只在概念上保留了 PC 寄存器(程序计数器),把其它寄存器都省掉了。

正是这个裁剪,让 JVM 变成了一台"被定制过的、现实中不存在的计算机":它只为执行 Java 字节码而设计,因此足够轻量、足够可移植。理解了"JVM 是一台定制虚拟机",后面所有的内存区域、执行引擎,都是这台定制计算机的某个零件而已。

顺带纠正一个常见拼写:原文里的 “VMwave” 是笔误,正确的写法是 VMware。

1.2 六款虚拟机串起的一部发展史

了解历史不是为了背年份,而是为了理解"为什么今天的 JVM 长成这个样子"。JVM 的发展,本质上是一场**"解释执行"与"编译执行"如何共存**的探索。

1)Sun Classic VM(1996,Java 1.0)
世界上第一款商业 Java 虚拟机。它内部只有解释器——这意味着它执行效率天生受限。最要命的设计缺陷是:如果想用 JIT(即时编译)来加速,JIT 必须"外挂"进来,而一旦 JIT 接管了执行,解释器就彻底罢工,二者不能协同工作。这个缺陷直到 JDK 1.4 都被淘汰。

2)Exact VM(JDK 1.2)
为了解决上面"解释器与编译器打架"的问题而生,它已经具备了现代高性能虚拟机的雏形:引入了热点探测(把反复执行的代码编译成机器码加速),并采用编译器与解析器混合工作的模式。可惜它只在 Solaris 平台短暂登场,最终被 HotSpot 取代,英雄气短。

3)HotSpot VM(当今霸主)

  • 最初由一家叫 Longview Technologies 的小公司设计,1997 年被 Sun 收购,2009 年 Sun 又被 Oracle 收购。
  • JDK 1.3 时成为默认虚拟机,如今无论是仍在用的 JDK 6,还是主流的 JDK 8,默认虚拟机都是 HotSpot,覆盖服务器、桌面、移动、嵌入式全场景。
  • "HotSpot"这个名字就来自它的招牌——热点代码探测技术。它通过计数器找到"最值得编译"的代码,触发 JIT 编译或栈上替换(OSR),让解释器与编译器协同工作,在"启动响应时间"和"峰值执行性能"之间取得平衡。这正是它超越前两者的关键。

4)JRockit(服务器端极致性能)
专注于服务端,内部没有解析器,所有代码都靠 JIT 编译执行——它不在乎启动速度,只在乎跑得够快。大量基准测试显示它曾是"世界上最快的 JVM",客户实测性能提升超 70%、硬件成本降低达 50%。它还有面向延迟敏感场景的 JRockit Real Time(毫秒/微秒级响应)和 MissionControl 监控套件。2008 年 BEA 被 Oracle 收购后,Oracle 承诺在 JDK 8 左右把 JRockit 的优秀特性移植回 HotSpot。

5)J9 JVM(IBM 出品)
全称 IBM Technology for Java Virtual Machine(IT4J,内部代号 J9)。市场定位与 HotSpot 接近,也是号称"世界最快"的商用虚拟机之一(在 IBM 自家产品上)。2017 年前后 IBM 将其开源为 OpenJ9,交给 Eclipse 基金会,即 Eclipse OpenJ9。

6)Taobao JVM / AlibabaJDK(国产之光)
由阿里 AliJVM 团队基于 OpenJDK HotSpot 深度定制,是整个阿里 Java 体系的基石。几个值得一提的黑科技(了解即可):

  • GCIH(GC Invisible Heap):把生命周期较长的对象挪出堆、放到 GC 管不到的地方,从而降低 GC 频率、提升回收效率,且能在多个 JVM 进程间共享。
  • 用 crc32 指令实现 JVM intrinsic,降低 JNI 调用开销。
  • 基于 PMU 硬件的 Java 性能剖析工具。
  • 针对大数据场景的 ZenGC。
    它在阿里内部全面替换了 Oracle 官方 JVM,代价是硬件严重依赖 Intel CPU、损失了兼容性——这提醒我们:性能优化往往是用兼容性换来的,没有免费的午餐。

1.3 规范与实现:别把"图纸"和"房子"搞混

上面 HotSpot、J9 这些,都是不同厂商对 JVM 的具体实现;而它们都必须遵守同一份"图纸"——《Java 虚拟机规范》。这是 Oracle 发布的 Java 领域最权威的著作,完整描述了 JVM 各组成部分的约定。

我用一个比喻帮你记住这三层关系:《规范》是建筑图纸,HotSpot / J9 是按图纸盖出来的不同房子。 图纸规定了"必须有客厅、卧室",但每个厂商可以用不同的砖和格局去实现。这也为后面"方法区可以有永久代 / 元空间两种实现"埋下了伏笔——它正是"一份规范、多种实现"的经典范例。


第二部分:JVM 如何执行一段 Java 程序

Java 程序从源码到跑起来,会经过四个核心组件的接力。理解了这条流水线,JVM 的骨架就立住了:

  1. 类加载器(ClassLoader):把 .class 字节码文件加载进内存(放进运行时数据区)。
  2. 运行时数据区(Runtime Data Area):JVM 运行程序时的内存布局,是存放各种数据的"仓库"。
  3. 执行引擎(Execution Engine):字节码是一套 JVM 自定义指令集,CPU 根本不认识它。执行引擎负责把字节码翻译成底层系统指令,再交给 CPU 执行。
  4. 本地库接口(Native Interface):当 Java 需要调用 C/C++ 等其它语言写的能力(比如访问操作系统底层)时,通过它来衔接。

一句话串起来:类加载器把字节码搬进运行时数据区 → 执行引擎把字节码翻译成机器指令 → 需要外部能力时经本地库接口调用。 这就是 JVM 执行 Java 程序的全部主线。


第三部分:运行时数据区——JVM 的"内存地图"

这是面试与实战的重灾区。我先帮你排除一个最大的坑,再逐一拆解。

重要澄清:运行时数据区(内存布局)≠ Java 内存模型(JMM)。 前者是"JVM 把内存分成了哪几块仓库"(物理视角),后者是"多线程访问共享变量时的一致性规则"(并发视角)。这是两个完全不同的概念,第六部分会专门讲 JMM。

运行时数据区由五大块组成。判断它们的关键,是先抓住一条主线——哪些是线程私有、哪些是线程共享:

区域是否线程私有一句话作用
程序计数器线程私有当前执行到哪一行
虚拟机栈线程私有方法执行的内存模型
本地方法栈线程私有给 Native 方法用
堆线程共享所有对象实例
方法区线程共享类信息、常量、静态变量

为什么需要"线程私有"? 因为 JVM 的多线程是靠线程轮流切换、分配 CPU 时间实现的。任一时刻,一个 CPU 内核只会执行一条线程的指令。为了让线程切换回来时能恢复到"我刚才执行到哪了",每条线程必须有独立的、互不干扰的存储区——这就是"线程私有"。理解了这一点,下面三个私有区就是它的自然推论。

3.1 堆(线程共享):所有对象的家

作用:程序中创建的所有对象实例都保存在堆里。我们最熟悉的两个 JVM 参数就是冲着它来的:

  • -Xms(memory start):堆的最小启动内存;
  • -Xmx(memory max):堆的最大运行内存。
    把它们设成相等是生产环境的常见做法,可以避免堆在运行时动态扩容带来的性能抖动。

堆的内部划分:堆分为新生代和老年代。新建对象进新生代,经历若干次 GC 仍存活的对象晋升到老年代。新生代又细分为 1 个 Eden + 2 个 Survivor(S0/S1)(注意:原文里写成的 “Endn” 是笔误,正确拼写是 Eden,意为"伊甸园")。垃圾回收时,会把 Eden 中存活的对象复制到一个空的 Survivor,再清空 Eden 和正在使用的那个 Survivor——这正是第五部分复制算法的落地。

3.2 虚拟机栈(线程私有):方法执行的舞台

作用:生命周期与线程相同。它描述的是Java 方法的执行模型——每执行一个方法,就创建一个栈帧(Stack Frame),用来存这个方法所需的一切。我们平时嘴里说的"栈内存",指的就是虚拟机栈。

每个栈帧包含四部分:

  1. 局部变量表:存放编译期可知的基本数据类型、对象引用(reference)等。它的空间在编译期就分配好了,运行期不会变。这里做个完善:原文说"8 大基本数据类型",但严格按规范,局部变量表存的是虚拟机可知的各种基本数据类型、对象引用和 returnAddress 地址,Java 的基本类型恰好是 8 种(byte/short/int/long/float/double/char/boolean)。简单记:它存方法参数和方法内的局部变量。
  2. 操作数栈:每个方法对应一个后进先出的栈,字节码的"计算"都在这个栈上完成。
  3. 动态链接:指向运行时常量池中该方法的引用,支撑把符号引用解析为直接引用。
  4. 方法出口 / 返回地址:方法执行完后回到调用处的位置。

3.3 本地方法栈(线程私有)

和虚拟机栈几乎一模一样,区别只有一个:虚拟机栈服务 Java 方法,本地方法栈服务 Native 方法。 HotSpot 干脆把两者合二为一了,这也是后文栈溢出只由一个 -Xss 参数控制的原因。

3.4 程序计数器(线程私有)

作用:记录当前线程正在执行的字节码行号/地址,是线程恢复执行位置的"书签"。

  • 若正在执行 Java 方法,它记录的是字节码指令地址;
  • 若正在执行 Native 方法,它的值为空(undefined)。

它是整个 JVM 规范里唯一一个明确规定"不会出现 OOM"的区域。正因为这块空间极小、职责极单一,才成了唯一的安全区。记住这条,面试几乎必考。

3.5 方法区(线程共享):类信息与常量的仓库

作用:存放被加载的类信息、常量、静态变量、JIT 编译后的代码等。

规范与实现的又一次呼应:规范里这个区域叫方法区;而 HotSpot 在 JDK 7 用永久代(PermGen)实现它,JDK 8 改用元空间(Metaspace)实现它。

原文这里有个非常好的比喻,但原文笔误把比喻对象写成了"制动器",正确应是"动能提供装置"。我帮你顺一遍:规范定义了"方法区"这个抽象概念,就像定义了"汽车需要动能提供装置";而燃油车用汽油发动机来实现,电动车用电机来实现——永久代之于方法区,就像汽油发动机之于动能提供装置;元空间之于方法区,就像电机之于动能提供装置。 同一个抽象要求,在不同时期换了一种实现技术而已。

JDK 8 元空间的两点关键变化(面试高频):

  1. 元空间使用本地内存(Native Memory),不再受 -Xmx 这类 JVM 最大堆参数限制,只受本机可用内存约束。这从根本上缓解了"永久代太小"的老问题。
  2. 字符串常量池从方法区移到了堆中。

运行时常量池是方法区的一部分,存放两类东西:

  • 字面量:字符串常量(JDK 8 已移到堆)、final 常量、基本类型值;
  • 符号引用:类和接口的全限定名、字段/方法的名称与描述符。

3.6 内存布局的异常实战:OOM 与 StackOverflow

光知道分区没用,能定位报错才算掌握。我把三类最经典的异常整理清楚,并保留了原文的复现代码。

① Java 堆溢出(OutOfMemoryError: Java heap space)

只要不断创建对象、并保证 GC Roots 到对象有可达路径(即无法被回收),当对象数量超过最大堆容量就会堆溢出。复现要点:先把堆锁死,让它无处可扩,并加上 Dump 参数方便事后分析。

// JVM 参数:-Xmx20m -Xms20m -XX:+HeapDumpOnOutOfMemoryError
public class Test {
    static class OOMObject {}
    public static void main(String[] args) {
        List<OOMObject> list = new ArrayList<>();
        while (true) {
            list.add(new OOMObject());
        }
    }
}

当异常信息是 java.lang.OutOfMemoryError: Java heap space 时,明确告诉你:问题发生在堆上。接下来要用 MAT 等工具分析 Dump 文件,区分两种病因:

  • 内存泄漏(Memory Leak):本该被回收的对象因可达路径没断而无法回收——要修代码;
  • 内存溢出(Memory Overflow):对象确实都该存活,是堆太小——调大堆参数,或缩短对象生命周期。
② 虚拟机栈 / 本地方法栈溢出

HotSpot 把两栈合一,栈容量只由 -Xss 控制,会产生两种异常:

  • 线程请求的栈深度 > 虚拟机允许的最大深度 → StackOverflowError;
  • 虚拟机扩展栈时申请不到足够内存 → OutOfMemoryError。

单线程下复现 StackOverflowError(典型场景:递归没有终止条件):

// JVM 参数:-Xss128k
public class Test {
    private int stackLength = 1;
    public void stackLeak() {
        stackLength++;
        stackLeak();
    }
    public static void main(String[] args) {
        Test test = new Test();
        try {
            test.stackLeak();
        } catch (Throwable e) {
            System.out.println("Stack Length: " + test.stackLength);
            throw e;
        }
    }
}

用默认参数,栈深度通常到 1000~2000 都没问题。StackOverflowError 是"栈太深",有堆栈可看、好定位;多线程 OOM 是"栈空间总量不够",此时若不能减少线程数,只能靠**减小最大堆或减小单栈容量(-Xss)**去换取更多线程。

多线程版复现会不断 new Thread 直到耗尽内存,运行前务必保存工作,生产环境更是要警惕线程数失控。


第四部分:类加载机制——一个类的"一生"如何开始

对程序员来说,类加载是 JVM 全流程里跟我们关系最密切的一环。

4.1 类加载的五个阶段

一个类的生命周期依次经历:加载 → 验证 → 准备 → 解析 → 初始化 → 使用 → 卸载。其中前五步合称"类加载过程",中间的验证、准备、解析三步统称为连接(Linking)。所以类加载可归纳为:加载 → 连接(验证 + 准备 + 解析)→ 初始化。

一个容易被忽略、也值得纠正的细节:很多资料(含原文)会说"这五步是严格固定的顺序"。这不严谨。只有加载与初始化的先后是确定的,而"验证、准备、解析"这三步在特定条件下可以延迟甚至调整顺序——比如"解析"就可能推迟到初始化之后再执行。规范把它们归为一组,是为了概念清晰,不代表运行时一定串行。

1)加载(Loading)
注意区分 加载 Loading(一个具体阶段)和 类加载 Class Loading(整个过程),别混为一谈。加载阶段做三件事:

  1. 通过类的全限定名获取该类的二进制字节流;
  2. 把字节流代表的静态存储结构,转化为方法区的运行时数据结构;
  3. 在内存中生成代表这个类的 java.lang.Class 对象,作为方法区各类数据的访问入口。

2)验证(Verification)
连接的第一步,确保字节流符合《规范》约束,保证这些代码运行后不会危害虚拟机自身安全。包含文件格式验证、字节码验证、符号引用验证等。

3)准备(Preparation)
为类变量(被 static 修饰的变量)分配内存并设置初始值。这个"初始值"是数据类型零值,而不是你代码里写的值。

public static int value = 123;

准备阶段 value 是 0,不是 123。123 这个赋值动作要等到初始化阶段才执行。这个坑几乎人人都踩过,务必记牢。

4)解析(Resolution)
把常量池里的符号引用替换为直接引用。符号引用是"我在哪个类找什么名字"的抽象描述,直接引用才是真正可用的内存地址/指针。

5)初始化(Initialization)
JVM 真正开始执行类中写的 Java 代码,把主导权交给应用程序。本质是执行类构造器 <clinit>() 的过程——静态变量赋值、静态代码块都在这里执行。

4.2 双亲委派模型

先明确一个 JVM 视角的事实:JVM 眼里只有两类类加载器——启动类加载器(Bootstrap ClassLoader,用 C++ 实现,是虚拟机自身的一部分),以及其余所有用 Java 实现、继承自 java.lang.ClassLoader 的加载器。

站在开发者视角,JDK 1.2 以来一直保持三层 + 双亲委派的架构:

  • 启动类加载器:加载 $JAVA_HOME/lib 下的核心类库;
  • 扩展类加载器:加载 lib/ext 下的类(补充:JDK 9 后它改名为 Platform ClassLoader,职责被模块化重整);
  • 应用程序类加载器:加载 classpath 下我们写的应用代码;
  • (必要时)还可自定义类加载器。

双亲委派是什么:一个类加载器收到加载请求,不会自己先加载,而是先向上委派给父加载器,层层上报,一直到最顶层的启动类加载器。只有当父加载器反馈"我范围内找不到"时,子加载器才自己动手。

为什么这么设计?两大好处:

  1. 避免重复加载:A、B 都继承 C,加载 A 时 C 已被顶层加载,加载 B 时 C 自然命中,不必重复;
  2. 安全:保护核心 API 不被篡改。如果没有双亲委派、谁都能加载自己版本的类,那我写一个 java.lang.Object,系统里就会出现多个 Object,而其中一些还是用户伪造的——安全性荡然无存。有了双亲委派,java.lang.* 永远由最可信的启动类加载器加载,伪造无效。

我的理解:双亲委派的本质是一次**“信任传递”**——越靠上的加载器越可信。它牺牲了一点灵活性,换来了核心类库的不可篡改。理解了这层"信任",才能理解下一节"为什么必须破坏它"。

4.3 破坏双亲委派:SPI 与 JDBC

双亲委派虽好,但有一个先天软肋:父加载器加载的类,无法访问子加载器才看得到的类。 SPI(Service Provider Interface,服务提供接口)机制就撞上了这堵墙。

SPI 是 Java 提供的一套"供第三方实现/扩展"的接口约定,用来为某个 API 寻找服务实现。最经典的例子就是 JDBC:

  • DriverManager、Connection 这些接口/类定义在 JDK 的 rt.jar 里,由 Bootstrap 加载器加载;
  • 但 Connection 的**具体实现(如 MySQL 驱动 jar)**是第三方提供的,位于 classpath,Bootstrap 看不到。

如果严格按双亲委派,Bootstrap 加载的 DriverManager 想加载它下游的 MySQL 驱动类,是加载不到的。解决办法是线程上下文类加载器(Thread Context ClassLoader):

// DriverManager.getConnection 源码节选
ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
synchronized (DriverManager.class) {
    if (callerCL == null) {
        callerCL = Thread.currentThread().getContextClassLoader();
    }
}

DriverManager 借助线程上下文加载器(默认是 Application ClassLoader)去加载具体驱动 jar。父加载器反过来借助子加载器才能拿到实现类,加载请求"逆向"向下了——这就是对双亲委派的破坏。

一句话记住:双亲委派的软肋是"父看不到子",而 SPI 需要"父用子",于是用线程上下文类加载器打通这条逆向通道。 类似的"破坏"还有 Tomcat 的 Web 应用类加载器、JOSGi 模块化热部署等,都是同一动因。


第五部分:垃圾回收——JVM 如何替你管理内存

前面三个区(程序计数器、虚拟机栈、本地方法栈)随线程生灭,回收确定;真正需要 GC 操刀的,只有堆和方法区。GC 的全部工作可以拆成三步:判断谁死了 → 用什么算法回收 → 由哪个收集器执行。

5.1 判断对象是否"死亡"

a)引用计数算法

给每个对象配一个计数器:有人引用就 +1,引用失效就 -1,计数为 0 即"死"。实现简单、判定高效,Python 就用它做内存管理。

但它有个致命硬伤:无法解决循环引用。两个对象互相引用、外部却再没人引用它们时,计数都 ≥1,永远回收不掉。所以主流 JVM 都没采用它。原文给了一个漂亮的反证实验:

// JVM 参数:-XX:+PrintGC
public class Test {
    public Object instance = null;
    private static final int _1MB = 1024 * 1024;
    private byte[] bigSize = new byte[2 * _1MB];
    public static void testGC() {
        Test test1 = new Test();
        Test test2 = new Test();
        test1.instance = test2;   // 互相引用
        test2.instance = test1;
        test1 = null;
        test2 = null;
        System.gc();              // 强制 GC
    }
    public static void main(String[] args) { testGC(); }
}

GC 日志输出 6092K -> 856K,说明这两个互相引用的对象被回收了。这直接证明:JVM 不是用引用计数法判断存活的。

b)可达性分析算法(Java/C# 采用)

以一组叫 GC Roots 的对象为起点向下搜索,走过的路径叫"引用链"。当某对象到 GC Roots 不可达时,判定它可回收。哪怕像 Object5~7 那样彼此还有关联,只要与 GC Roots 断了链,照样回收。

哪些能成为 GC Roots?

  1. 虚拟机栈(栈帧局部变量表)中引用的对象;
  2. 方法区中类静态属性引用的对象;
  3. 方法区中常量引用的对象;
  4. 本地方法栈中 JNI(Native 方法)引用的对象。

理解到这里,你会发现"引用"这个角色变了:过去我们用引用"找对象",现在还用引用"判断对象死没死"。正因如此,JDK 1.2 把引用概念扩充为四种,强度依次递减:

  • 强引用:Object obj = new Object() 这种,只要它在,回收器永不回收;
  • 软引用(SoftReference):描述"有用但非必须"的对象。系统即将 OOM 前才把它列入回收,回收后还不够才抛 OOM。适合做缓存;
  • 弱引用(WeakReference):比软引用更弱,只要 GC 一发生就被回收,不管内存够不够;
  • 虚引用(PhantomReference):最弱。有没有虚引用完全不影响对象生存期,也无法通过它取得对象实例。唯一目的:在对象被回收时收到一个系统通知。

5.2 垃圾回收算法

把死对象标记出来后,怎么清?有四种思想。

a)标记—清除
最基础:先标记要回收的对象,再统一清除。两大不足——效率不高(标记、清除两步都慢);产生大量内存碎片,碎片太多时,将来分配大对象找不到足够连续空间,只能提前触发一次 GC。

b)复制
为了解决效率问题。把内存分大小相等的两块,只用一块,回收时把存活对象整体复制到另一块,再一次性清空原块。好处:无碎片、指针按序移动即可、实现简单、运行高效。
新生代就用它——因为新生代里约 98% 的对象"朝生夕死",需要复制的对象极少。所以不必 1:1 切分,而是划成 1 块 Eden : 2 块 Survivor,HotSpot 默认 Eden : Survivor = 8:1,即 Eden : From : To = 8:1:1,每次可用约 90%,留 10% 存存活对象。Survivor 不够时由老年代做分配担保。
HotSpot 复制算法流程:

  1. Eden 满触发 Minor GC,把存活对象复制到 Survivor From;
  2. 下次 GC 扫描 Eden + From,存活者复制到 To,清空 Eden、From;
  3. 再下次在 Eden + To 间进行,存活者复制回 From……对象在 From/To 间反复横跳,交换次数默认上限 15 次(-XX:MaxTenuringThreshold),仍存活就晋升老年代。

c)标记—整理
复制算法在存活率高时复制成本太大,所以老年代不用它。标记—整理的标记步骤同标记—清除,但后续不是清除,而是让所有存活对象向一端移动,再清理掉边界外的内存。适合老年代。

d)分代收集(当今通用思想)
它不是新算法,而是分区 + 分策——正如原文"一国两制"的比喻:不同区域用不同策略。一般把堆分为新生代和老年代:新生代大批对象朝生夕死、存活少 → 用复制算法;老年代存活率高、无额外空间担保 → 用标记—清除或标记—整理。

  • 哪些进新生代:刚创建的对象;
  • 哪些进老年代:大对象,以及经历 N 次(默认 15)GC 仍存活的对象。

Minor GC vs Full GC(高频面试题):

  • Minor GC(新生代 GC):发生在新生代,因对象朝生夕死所以频繁、速度快,用复制算法;
  • Full GC / Major GC(老年代 GC):发生在老年代,常伴随至少一次 Minor GC,速度通常比 Minor GC 慢 10 倍以上。

5.3 垃圾收集器:算法的具体实现

算法是方法论,收集器是落地。先记住三个概念,避免混淆:

  • 并行(Parallel):多条 GC 线程并行工作,但用户线程仍要等待;
  • 并发(Concurrent):GC 线程与用户线程同时执行(可能交替),用户程序继续跑;
  • 吞吐量 = 运行用户代码时间 / (运行用户代码时间 + GC 时间)。

为什么会有这么多收集器? 因为它是历史演进的产物,每个都在解决前一个的痛点:
Serial(串行) → ParNew(Serial 的多线程版) → Parallel Scavenge / Parallel Old(吞吐量优先) → CMS(低停顿/并发) → G1(全区域、可预测停顿)。

下面逐个说清"它是谁、它为谁而生、代价是什么"。

a)Serial(新生代,串行)【选学】
最古老,单线程。"单线程"重点不只是用一个 CPU,而是回收时必须暂停所有工作线程(Stop The World,STW)。它是 Client 模式下的默认新生代收集器——在单 CPU 环境里,没有线程交互开销,反而能拿到最高单线程效率。

b)ParNew(新生代,并行)【选学】
Serial 的多线程版,其余(参数、算法、STW、策略)完全一致。Server 模式下曾为首选,一个与性能无关却关键的原因是:当时只有它能和 CMS 配合。 但单 CPU 下它未必比 Serial 强(有线程交互开销)。

c)Parallel Scavenge(新生代,并行)【选学】
复制算法 + 并行多线程。它和别的收集器关注点不同:别人追求"最短停顿",它追求"可控吞吐量",故称"吞吐量优先"收集器。 两个控制参数:

  • -XX:MaxGCPauseMillis:最大 GC 停顿时间;
  • -XX:GCTimeRatio(原文写作 GCRatio,准确参数名是 GCTimeRatio):直接设置吞吐量大小。
    注意一个反直觉的点:缩短停顿时间,往往是拿吞吐量和新生代空间换来的(比如从 10 秒一次停 100ms,变成 5 秒一次停 70ms,停顿降了、吞吐也降了)。它还有一个杀手锏——GC 自适应调节策略(-XX:+UseAdaptiveSizePolicy):开启后无需手工指定新生代大小、Eden/Survivor 比例、晋升年龄,虚拟机会根据运行情况自动调优。它适合后台运算(要吞吐),ParNew/CMS 适合强交互(要低停顿)。

d)Serial Old(老年代,串行)【选学】
Serial 的老年代版,单线程、标记—整理。主要给 Client 模式用;在 Server 模式下两大用途:JDK 1.5 及以前搭配 Parallel Scavenge,以及作为 CMS 的后备预案(发生 Concurrent Mode Failure 时顶上)。

e)Parallel Old(老年代,并行)【选学】
Parallel Scavenge 的老年代版,多线程 + 标记—整理(JDK 1.6 才有)。在它出现前,Parallel Scavenge 只能配单线程的 Serial Old,老年代拖后腿,整体吞吐反而不一定比 ParNew + CMS 强。有了它,"吞吐量优先"才算名副其实。

f)CMS(老年代,并发)——重点
CMS(Concurrent Mark Sweep,并发标记清除)以最短回收停顿为目标,正是互联网 / B/S 服务端最需要的(响应快、体验好)。它基于"标记—清除",分四步:

  1. 初始标记(只标记 GC Roots 直接关联的对象,快,STW);
  2. 并发标记(GC Roots Tracing,与用户线程并发);
  3. 重新标记(修正并发期间变动的标记,STW,比初始标记稍长但远短于并发标记);
  4. 并发清除(与用户线程并发)。
    耗时最长的两步都能并发,所以整体是并发回收,优点就是"并发、低停顿"。

但它有三个缺点,必须同时记住:

  1. 对 CPU 敏感:并发阶段虽不停顿,却占用 CPU 线程拖慢应用、降吞吐。默认回收线程数 =(CPU 数 + 3)/ 4;当 CPU < 4 个时,影响可能很大;
  2. 无法处理"浮动垃圾":并发清除时用户线程还在产生新垃圾,这部分留在标记之后,本次清不掉,称为浮动垃圾。因为要给运行中的用户线程预留空间,CMS 不能像别的收集器那样等到老年代填满才回收;若预留空间不够,会触发 Concurrent Mode Failure,临时退回单线程 Serial Old,停顿变得很长;
  3. 产生大量空间碎片(毕竟是标记—清除),碎片太多时大对象找不到连续空间,被迫提前 Full GC。

g)G1(唯一全区域收集器)——重点
G1(Garbage First)面向 heap 很大的场景:把堆划成众多 Region,并行回收,清理后还做内存压缩。它整体基于"标记—整理"、局部两个 Region 间基于"复制",按 most garbage 优先回收,且回收单个 Region 基本不 STW。一个 Region 可属于 Eden(E) / Survivor(S) / Tenured(T),还新增 Humongous(H) 区存大对象(超过 Region 大小 50% 的对象)。

  • 年轻代回收:复制算法,把 Eden/Survivor 对象复制到新 Survivor。
  • 老年代回收四阶段(与 CMS 神似但有巧思):
    1. 初始标记:与 Minor GC 一同发生,不必像 CMS 那样单独暂停一次;
    2. 并发标记:标记过程中若发现某 Tenured Region 存活率极低,当场回收(这正是 “Garbage First” 名字由来),同时统计各 Region 存活率供后续用;
    3. 最终标记:用 SATB(snapshot-at-the-beginning) 算法更快标记可达对象;
    4. 筛选回收(Clean up / Copy):没有 CMS 的 Sweep,而是挑存活率低的 Region 回收,也与 Minor GC 一同发生。
      G1 的使命是未来替换 CMS。追求低停顿选 G1;追求吞吐量,G1 并不带来明显优势。

一张"收集器全家福"的记忆口诀:新生代看 Serial / ParNew / Parallel Scavenge;老年代看 Serial Old / Parallel Old / CMS / G1;能连线代表能搭配。G1 是唯一横跨全区域的异类。

5.4 一个对象的一生

把前面所有概念揉进一个小故事(原文写得极生动,我稍微润色):

我是一个 Java 对象,出生在 Eden,和许多长得像的小兄弟一起玩耍。有一天 Eden 太挤了,我被迫漂到 Survivor 的 From 区;从此我开始漂,一会儿在 From、一会儿在 To(S0/S1)区,居无定所。直到我"18 岁"(年龄到阈值,默认 15),爸爸说"你成人了,去社会上闯闯",于是我被晋升到老年代。这里人多、年纪大,我认识了很多人。在老年代我又生活了很多年(每次 GC 加一岁),最终被回收。

这段拟人化,恰好把"Eden 满触发 Minor GC → 在 From/To 间复制 → 年龄到阈值晋升老年代 → 老年代回收"整条链路讲完了。理解了"一个对象的一生",你就理解了堆与 GC 协同的全部主线。


第六部分:JMM——并发世界的"交通规则"

最后一个板块,也是最烧脑的。先再次强调:JMM(Java Memory Model)与运行时数据区无关。 它要解决的是:同一个程序,为什么在 A 平台上并发正常、在 B 平台上却出错? 因为 C/C++ 直接用物理硬件的内存模型,平台差异会导致并发行为不一致。JMM 就是一层抽象,屏蔽掉硬件/操作系统的差异,让 Java 在所有平台上都有一致的内存访问效果。

6.1 主内存与工作内存

JMM 定义的是共享变量的访问规则。它管的是实例字段、静态字段、数组元素;不管局部变量和方法参数——因为它们本来就是线程私有的,不会被共享,自然无需协调。

规则核心:

  • 所有变量都存在主内存(相当于堆);
  • 每条线程有自己的工作内存(相当于栈/寄存器),保存所用变量的主内存副本拷贝;
  • 线程对变量的所有操作(读、写)都必须在工作内存中进行,不能直接读写主内存;
  • 线程之间无法直接访问对方的工作内存,变量值的传递一律通过主内存。

这套"主内存 ↔ 工作内存"的结构,正是很多并发 Bug 的根源:你改的是副本,别人看不到。

6.2 内存间的八种交互操作

变量怎么从主内存拷到工作内存、又怎么同步回去?JMM 定义了 8 种原子操作:

  • 作用于主内存:lock(锁定,独占)、unlock(解锁)、read(读取到工作内存通道)、write(写入主内存);
  • 作用于工作内存:load(载入副本)、use(传给执行引擎)、assign(赋值给副本)、store(传回主内存通道)。

6.3 JMM 三大特性 + happens-before

原子性:JMM 直接保证的原子操作包括 read、load、use、assign、store、write 这六种。

注意:原文这里把六个操作写错了(重复写了两次 read,漏了 write),正确六个是上面这一组。基本类型读写大致都具原子性;要更大范围的原子性,得靠 synchronized。

可见性:一个线程改了共享变量,其它线程能立即得知。volatile、synchronized、final 可实现可见性。

有序性:本线程内观察,操作有序(“线程内表现为串行”);跨线程观察,操作无序(源于指令重排序和主/工作内存同步延迟)。

要保证程序并发正确,原子性、可见性、有序性三者缺一不可。

happens-before(先行发生原则):JMM 内置的、无需额外手段就能保证的有序性。若两操作的先后无法由它推导出来,虚拟机就可以随意重排。八条规则:

  1. 程序次序规则:同一线程内,靠前的代码先行于靠后的;
  2. 锁定规则:一个 unlock 先行于后续对同一锁的 lock;
  3. volatile 变量规则:对 volatile 变量的写,先行于后续对它的读;
  4. 传递规则:A 先行于 B、B 先行于 C,则 A 先行于 C;
  5. 线程启动规则:Thread.start() 先行于该线程的每个动作;
  6. 线程中断规则:interrupt() 调用先行于被中断线程检测到中断;
  7. 线程终止规则:线程内所有操作先行于它的终止检测(join() 返回、isAlive() 返回 false);
  8. 对象终结规则:对象初始化完成先行于它的 finalize() 开始。

6.4 volatile:最轻量的同步,也是最容易被误解的关键字

volatile 是 JVM 提供的最轻量级同步机制,却极容易被误用。它给变量带来两种特性:

特性一:保证可见性。 一个线程改了 volatile 变量,新值能被其它线程立即看到(普通变量做不到,普通变量得等回写主内存后别人再读才可见)。

但这里有个最致命的误区,原文讲得很到位,我帮你再钉死一遍:volatile 保证可见性,但绝不保证原子性。 看自增例子:

public static volatile int num = 0;
public static void increase() { num++; }
// 10 个线程,每个自增 100 次,理想结果应是 1000

实际结果往往小于 1000。因为 num++ 等价于 num = num + 1,是"读—改—写"三步而非原子操作:volatile 能保证"读 num 时读到的是最新值",但在执行 +1 的间隙,别的线程可能已经把 num 改大了,于是本线程又用旧值算出的较小结果覆盖回去。volatile 适合的场景只有两类:

  1. 运算结果不依赖变量当前值,或能保证只有一个线程改它;
  2. 变量不需要与其它状态变量共同满足不变约束。

一个完美契合的场景——开关标志:

volatile boolean shutdownRequested;
public void shutdown() { shutdownRequested = true; }
public void work() {
    while (!shutdownRequested) {
        // do stuff
    }
}

shutdown() 被调用后,所有线程的 work() 都能立即停下来。

特性二:禁止指令重排序。 语义有两层:① 执行到 volatile 读/写时,其前面的操作一定已完成且结果可见,其后面的操作一定还没做;② 编译器优化时,不能把 volatile 之前的语句挪到它后面,也不能把之后的语句挪到它前面。

经典例子(flag 为 volatile,x、y 为普通变量):

x = 2;        // 语句1
y = 0;        // 语句2
flag = true;  // 语句3(volatile)
x = 4;        // 语句4
y = -1;       // 语句5

volatile 保证:语句 3 不会被重排到语句 1、2 之前,也不会被排到语句 4、5 之后;执行到语句 3 时,语句 1、2 必定已完成且对后续可见。但语句 1 与 2 之间、语句 4 与 5 之间的顺序不受保证。

终极实战:双重检查锁单例(DCL)为什么必须加 volatile。

public static Singleton getSingleton() {
    if (instance == null) {                 // 第一次检查
        synchronized (Singleton.class) {
            if (instance == null) {         // 第二次检查,防止多线程同时进入外层 if
                instance = new Singleton();
            }
        }
    }
    return instance;
}

看似完美,实则有问题。instance = new Singleton() 在 JVM 里并非原子,大致分三步:

  1. 给 instance 分配内存;
  2. 调用构造器初始化成员变量;
  3. 把 instance 指向这块内存(执行完这步 instance 就非 null 了)。

由于 JIT 的指令重排序,步骤 2 和 3 可能颠倒(变成 1-3-2)。一旦线程 A 执行完 3、还没执行 2,就被线程 B 抢占:此时 instance 已非 null 但还没初始化,B 在外层 if (instance == null) 处判为 false,直接返回一个"半成品"对象,随后使用时就报错。

解决办法只需把 instance 声明为 volatile:

class Singleton {
    private volatile static Singleton instance = null; // 禁止重排,保证对象完整
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

volatile 在这里不是为可见性,而是为"禁止指令重排序",确保返回的对象一定被完整初始化过。这是理解 volatile 价值的最佳范例。


结尾(总结篇):把一台"虚拟计算机"重新拼回去

走完这一遭,让我们回到开头那个比喻——JVM 是一台被定制出来的、现实中不存在的计算机——现在你应该能亲手把它拼装起来了:

  • 它有CPU 和执行逻辑:执行引擎把字节码翻译成机器指令,本地库接口负责跟外部世界对话;
  • 它有内存:运行时数据区——堆、方法区共享,程序计数器、虚拟机栈、本地方法栈按线程私有;
  • 它有装填程序的流程:类加载器把字节码搬进来,经过加载、连接、初始化,并靠双亲委派维持核心类库的信任链;
  • 它有内存管理员:垃圾回收先判断对象死活,再用复制/标记清除/标记整理/分代策略,由 Serial 到 G1 的一族收集器执行;
  • 它还额外为多核并发时代制定了内存访问规则:JMM,靠主/工作内存、原子性、可见性、有序性与 happens-before,把 Java 的并发行为锁死成"到处一致"。

如果只让我留下三条最该带走的认知,是这三条:

  1. "规范 vs 实现"是理解 JVM 的钥匙。 方法区有永久代/元空间两种实现、JVM 有 HotSpot/J9/OpenJ9 多种实现——凡是遇到"它到底是什么"纠结时,先问一句"规范怎么定的、这一家怎么实现的",多数困惑立刻消解。
  2. 没有银弹,只有取舍。 ParNew 单 CPU 不一定快、CMS 低停顿却耗 CPU 还留碎片、G1 低停顿却吞吐一般、阿里 JVM 提速却绑死 Intel。JVM 的每一个设计,都是在两个目标之间做权衡;调优的本质是选对你的那个取舍。
  3. volatile 的"轻量"恰恰是它的边界。 它管可见性和有序性,唯独不管原子性——这条边界,正是无数并发 Bug 的分界线,也是判断一个人是否真懂并发的试金石。

JVM 的知识浩繁,但它的底层叙事其实只有一句话:用一层抽象,屏蔽底层差异,让同一份代码在任何硬件上都能跑对、跑好。 读懂这层抽象,你记住的就不再是一堆名词,而是一台计算机的设计哲学。


评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址