一、引言

在 Java 编程语言的世界里，Java 虚拟机（JVM）是支撑一切的核心基础。作为一个开发者，理解 JVM 的工作机制不仅能帮助我们编写更高效的代码，还能在面对性能问题时提供深刻的洞察。JVM 并非一个简单的运行环境，它包含了复杂的内存管理系统、类加载机制和垃圾回收机制，这些组成部分共同保障了 Java 应用的稳定性和性能。

在这篇博客中，我们将深入探讨 JVM 的内部构造。我们将从 JVM 的内存区域划分入手，了解各个内存区域的功能和管理方式；接着，我们将解密 Java 类加载机制，揭示类加载的全过程及其背后的原理；最后，我们会分析 JVM 的垃圾回收机制，探索如何通过有效的回收策略优化内存使用。无论你是 Java 初学者还是经验丰富的开发者，这些知识都将帮助你更好地理解 Java 的运行时环境，并在实际开发中运用自如。

二、内存划分

首先看一张图：

这张图上画的是一个 JVM 的进程中内存划分的示意图，首先先介绍左边偏上的那部分板块，那部分板块主要是放线程的。

2.1、线程区

相信大家也都能看到，每个线程中呢会划分为两个区域，一个是我们很熟悉的栈区，另外一个就是程序计数器。首先介绍栈区吧。

a）栈区

栈区中主要存放的是方法之间的调用关系以及局部变量，调用关系呢就比如说我们的递归，所以当我们递归的次数过多时，就会导致出现栈溢出的情况。

b）程序计数器

这部分主要是记录当前线程执行的下一条指令的内存地址，而这个内存地址指的就是方法区中的内存地址。

2.2、方法区（元数据区）

这里面主要就是放类对象的 class 文件、方法内容、static 成员这些。

2.3、堆

这里面主要是放 new 的对象的。

好了，理论完成，开始实践，请看一段代码，如下：

class Text1 {
    public static int a;
    public int b;
}
public class Text {
    public void c() {
        int d;
        Text1 t = new Text1();
    }
    public static void e() {
        int f;
    }
}

请问在上述代码中，a、b、c、d、e、f、t 分别是在哪个区域中呢？

• 栈区：d、f、t（这里是指 t 本身）
• 方法区：a、c()、e()
• 堆：b、t（这里指 t 所 new 出来的对象）

怎么样？是否答对了呢？这块区域划分还是比较简单的。紧接着就进入类加载机制的模块吧。

三、类加载机制

JVM 的类加载机制其实就是把类从硬盘（文件）里加载到内存中，只要理解了这句话，那么接下来的分析就会听的很轻松了。

Java 程序，我们最开始写的都是一个 .java 文件，然后编译成 .class 文件，也就是我们所说的字节码，然后当我们运行 .java 程序的时候，JVM 就会读取 .class 文件，把文件中的内容放到内存中，并且构造成 .class 对象，也就是我们常说的类对象。

3.1、加载

这一步很简单，首先找到 .class 文件，然后打开文件，读取内容，并且尝试解析格式。

3.2、验证

验证以下当前的 .class 文件格式，是否符合要求，虽然说这个文件是个二进制文件，但是内部也是有一定的结构的，如下表：

具体是干嘛的这里就不过多解释，想要了解的可以自行查阅官方文档。

3.3、准备

到这个阶段就是给类对象分配内存空间了，最终目标就是构造出完整的类对象，分配内存+初步的初始化。这次分配出来的内存空间呢，内容全部都是 0，此时此刻，类对象上的 static 的成员也就都是 0 了.

3.4、解析

主要是初始化类对象中涉及到的一些字符串常量，其实字符串常量在 .class 文件中就已经存在了，这次直接读取到内存中就行了。但是，在初次分配内存的时候，这些字符串常量的地址是常量池内的符号引用的地址，这次是将符号引用替换成直接引用。那什么是符号引用什么是直接引用呢？例子老哥出现：

学校在大礼堂开会大家都经历过吧？还没进去的时候我们是不知道自己的准确位置是在哪里的，就指知道自己是班里面的第几个，然后排着队进去，这个 "班里面第几个" 这个位置就是我所说的符号引用的地址，然后等进去到礼堂之后，这时候坐下了就确定好位置了，此时这个位置就是直接引用的地址了。

3.5、初始化

对类对象进行更具体的初始化操作，初始化静态成员，执行静态代码块，加载父类......这一系列操作。

3.6、双亲委派模型

这个双亲委派模型是 JVM 里面比较重要的一个模型了，主要是描述类加载的过程。这个模型中的委派，究竟是如何委派？委派给谁呢？欸，我们之前是不是学过数据结构中的树啊？里面有子节点和父节点，这个双亲就和这个父子节点有点类似，看下图：

最上面那个就是最大的父了，首先我们的程序启动，从 Application ClassLoader 开始，先不加载，需要什么类全部抛给他的父亲，也就是我们的 Extension ClassLoader ，然后它拿到需要加载的类的时候，发现它也有爸爸，它也不加载了，也抛给它的父亲：Bootstarp ClassLoader ，它也想抛，但是它已经没有父亲了（我哭死），然后只能它自己加载了，要是有这个类，就加载好直接返回，要是没有这个类，就抛给他的儿子，也就是 Extension ClassLoader 进行加载，同理，要是它加载好了就万事大吉，要是没加载好还得往下抛，如果最底层的 Application ClassLoader 都没找到这个类，那就会抛异常。这就是所谓的双亲委派模型，其实说白了就是一个找文件的过程。

那么一个类什么时候会被加载呢？懒汉模式，也就是说只有被用到的时候才会加载。

四、JVM 垃圾处理机制

这个垃圾处理机制，主要是要干啥呢？很明显，处理程序中的垃圾嘛，那什么才能称为垃圾呢？也很简单，只要后面一直用不到了，就可以视为垃圾，也就可以被释放掉了。

在 C语言中，完全是靠程序猿手动释放的，而我们都知道，要是代码简单一点还好，如果很复杂的一个代码，难免会疏忽，出现纰漏，所以靠程序猿来做这件事情肯定是不靠谱的。那我们的 C++ 呢就引入了智能指针（但是感觉并不是很智能），Java/Python/Ruby/PHP/Go 则是引入垃圾回收（GC）机制，这个机制最大程度了解放程序猿，但是有个比较严重的问题，那就是虽然说这个机制好，但是也是需要时间来扫描这个项目的，严重点的情况还会引发 STW 问题。

那么垃圾回收机制到底是要干啥呢？对于 Java 来说，回收的其实是对象而不是字节，你想想嘛，如果说某个字节不要了就回收，每次回收肯定是需要时间扫描线程的，那也太浪费时间了。继续分析，一个 JVM 进程内存的划分总共就那几个部分，栈是不需要 GC 回收的，每个栈区里面有很多"栈帧"，每个栈帧对应一个方法，该方法结束时，这个栈帧就销毁了，同理，栈帧上的局部变量啊，程序计数器这些也跟随着线程的销毁一起跟着销毁了。方法区也不太会涉及到对象的卸载，所以对于 Java 来说，GC的主要战场是在堆上。

垃圾回收总共分两步。

4.1、判断对象是否是垃圾

如果说一个对象，在后续的代码中不会被继续使用了，就可以当作垃圾了。那又怎么知道这个对象它后面会不会被使用到呢？欸，可以根据对象的引用嘛，如果说没有引用指向它了，那根本就拿不到这个对象了，可不就是垃圾了吗？例如这个代码：

public class Text {
    public void c() {
        int d;
        Text1 t = new Text1();
    }
    public static void e() {
        int f;
    }
}

比如说这里面的 t，如果说 c() 方法执行完了，那是不是 c 的栈帧就被释放了呀？t 也就跟着没了，当 t 没了之后，就拿不到原本的 t 所指向的对象了，这时候这块空间就是垃圾空间了。

思路一、引用计数

给这个对象里面安排一个计数器，每次有引用指向它，计数器就 + 1，每次销毁引用，计数器就 - 1，乍一听这个方法是不是很好啊？这思路多清晰，并且方便计算。但是，这个方法还是有弊端的，并且弊端很大，第一个弊端：每次申请空间的时候，还需要多申请一块来放计数器，不好。第二个弊端，你说有没有可能，在这个计数器还没归零的时候，已经拿不到这个地址了呢？代码如下：

class T {
    public T t;
}
public class Text {
    public static void main(String[] args) {
        T a = new T();
        T b = new T();
        a.t = b;
        b.t = a;
        a = null;
        b = null;
    }
}

看上面这个代码，首先执行到 b.t = a; 还是一切安好是吧，有每个对象开辟的空间里面都有两个引用指向这块空间，但是当我们发现，我们把 a 和 b 一但制空，他们这里面的计数器也就只减一次，这是因为我们 a 和 b 里面还是有一个 t 指向它的，可是我们 a 和 b 都已经拿不到了，想拿到他们的 t 就更是无稽之谈，所以这个思路没用站住脚跟，接下来没有时间悲伤，紧接着到来的是可达性分析。

思路二、可达性分析（也是 Java 中实际采取的方案）

首先 JVM 会从现有代码中的能直接访问到的引用触发，尝试访问所有能访问的对象（比如栈上的局部变量，常量池里面的引用，方法区中的静态成员），如果说该对象能访问到，就会被标记成 "可达"，整个都遍历完之后，可达以外的对象，也就相当于是垃圾了。这个方法就非常好，但是也有瑕疵，那就是需要周期性的扫描，每次扫描都会花费时间，但是这也是没办法的，总得有点代价吧，一个程序中，这个代价要么就是时间要么就是空间，只能说尽可能的优化扫描的这个过程，比如说多线程并发着扫描，尽可能的减少扫描时间，所以我在上面才会说，严重的情况会引发 STW 问题。

4.2、如何释放对象的内存

思路一、标记-清除

很简单，听名字就能理解嘛，也就是说把标记好的垃圾给删除了，不是垃圾就不删，这种方法也有缺点，先看一张图：

假设说黑色的区域是垃圾内存，那如果说一块黑色区域的内存大小只有 1mb，现在删除了，后续我要申请一个 3mb 大小的内存怎么办？首先我们申请的这一整块内存肯定是要连续的，那不就申请不成功了吗？随着我们内存申请，内存释放的次数增多，我们可使用的整块空间会越来越小，全都变成零散的空间了，所以说这种方法 out 了。

思路二、复制算法

也很简单，光听名字就知道要干嘛了，就是说把我们的空间划分成两个区域，然后等扫描一轮结束后，还没被销毁的内存就从一个区域移动到另外一个区域，这种方法还是不行，虽然说解决了上述问题，但是非常的耗费空间和时间。

思路三、标记整理

这个方法类似于顺序表中，中间元素的删除，直接把后面的元素往前面覆盖就行了，但是缺点还是很明显，非常的消耗时间。

大结合、分代回收

这个方法就是我们 JVM 使用的方法了，分代回收，分什么代？爷孙代（bushi），差不多就这个意思。看下图：

首先看新生代这块区域，主要是刚进入第一轮扫描的对象，这些对象大多都过不了第一轮扫描，少数存活下来的对象进入幸存区，幸存区有两个大小相同的空间，每次只用其中的一部分，主要是应对接下来的几轮扫描，扫描过的就从一块幸存区复制到另外一块，来来回回扫描几次，就进入老年代，这就说明这个对象可能是一个生命周期比较长的对象了，还有一种方式也可以进入老年代，那就是这个对象十分的大，因为对象太大的话复制起来不方便。而老年代就不经常扫描了，主要是以标记整理为主。

五、总结

在本文中，我们深入探讨了 Java 虚拟机（JVM）的核心构成和机制。我们首先了解了 JVM 的内存区域划分，包括线程区、方法区（元数据区）、堆等，并通过实例代码分析了不同变量和对象在内存中的存放位置。接着，我们详细介绍了 JVM 的类加载机制，从加载、验证、准备、解析到初始化，揭示了类加载的全过程，并讲解了双亲委派模型的工作原理。最后，我们探讨了 JVM 的垃圾回收机制，介绍了对象的判定为垃圾的标准以及几种常见的垃圾回收算法，特别是 JVM 使用的分代回收机制。

通过这篇文章，我们不仅揭开了 JVM 的神秘面纱，还为开发者提供了一些实用的知识和技能，使得在日常编程中能更好地理解和优化 Java 应用的性能。掌握这些知识，不仅能帮助开发者解决内存泄漏等常见问题，还能在系统设计中做出更明智的决策。

六、结语

在探索 Java 虚拟机（JVM）的过程中，我们不仅揭开了它的神秘面纱，还感受到了其强大而复杂的设计。JVM 的内存管理、类加载机制和垃圾回收策略，为 Java 开发者提供了稳固的基础。通过理解这些核心概念，我们不仅能更好地编写高效代码，还能在面对性能瓶颈时游刃有余地做出调整。

作为 Java 开发者，我们的学习之路没有尽头。每一次深入探究 JVM 的内部构造，都是一次自我提升的机会。掌握这些技术细节，不仅仅是为了解决问题，更是为了在编程的世界里不断突破自我，迎接新的挑战。无论你是初出茅庐的新手，还是经验丰富的老手，永远保持对知识的渴望和对技术的热爱，才能在不断变化的技术浪潮中站稳脚跟。

愿我们在未来的编程道路上，一路披荆斩棘，不断超越自我，实现更高的目标。相信在不懈的努力和学习中，我们都会成为更好的自己。继续前行，梦想就在不远的前方！