引言
我在上篇文章：[JVM | 基于类加载的一次完全实践]JVM | 基于类加载的一次完全实践 - 掘金 (juejin.cn) 中为你讲解如何请"建筑工人"来做一些定制化的工作。但是，大型的Java应用程序时，材料（类）何止数万，我们直接堆放在工地上（JVM）上吗？相反，JVM有着一套精密的管理机制，来确保类的加载、验证、解析和初始化等任务能够有序且高效地完成。 在Java的世界中，虚拟机（JVM）是我们每一个程序的运行环境，而它的内存结构 更是决定我们程序运行性能的关键因素。理解JVM的内存结构，不仅可以帮助我们编写出更高效的代码，而且可以在程序出现问题时，更快地定位并解决问题 。然而，JVM内存结构的复杂性，很多人仍然存在许多误解和疑惑。 在本篇文章中，我们将详细地探讨这些"建筑工人"是如何处理"建筑材料"的，从而帮助你更深入地理解JVM类加载和初始化的内部工作机制。希望通过这篇文章，可以带你更深入地理解Java程序的运行机制。让我们开始吧！
类的加载
我在之前为你讲解了类的生命周期，你还记得吗？我们来回顾下：加载、验证、准备、解析、初始化、使用和卸载。 接下来，我们再深入分析完整的过程。
加载类进JVM内存
还是以Building为例。假设你在编译器中编写了Building类，并生成了相应的字节码文件Building.class。当你启动你的Java程序时，首先JVM启动并初始化。在这个过程中，JVM的类装载子系统 起着关键的作用。类装载子系统的主要职责就是加载类到JVM中。当类被加载时，Java虚拟机首先将类的元信息 放入运行时数据区的元空间中，然后在堆中生成java.lang.Class类的实例。这个Class对象会包含指向元空间中类元信息的引用。文字还是过于抽象，我画了一张图，你看： 
这里有几个让人混淆的地方，我来为你解释一下：
两个Class
图中有两处Building.class。但是，此Class非彼Class。第一步的Class代表着Building的字节码文件。而第二步的Class则为指向Building类元信息的Class对象。
两处元空间
这里我从不同的JDK内存结构讲起，你可以比较这两者差异： 在JDK7里，类元数据信息被存储在堆的一部分，叫做方法区 ，它需要参与垃圾回收，但时常被GC忽略。所以方法区的存在让内存管理成本变高，而且在空间分配不当的情况下，容易出现内存溢出的情况。 所以在JDK8时，将方法区 改为元空间 ，并把其移到本地内存中，这样可以更好地管理内存，避免出现内存溢出的情况。
JVM内存和直接内存
在图中你可以看到，JVM内存 和本地内存 都属于(物理)内存的一部分，为什么要把它们分开讨论呢？因为目标不同，JVM是由JVM进程管理的一块内存空间，它可以对其中的内存进行自动垃圾收集。而本地内存是不受JVM管理，而且不受JVM内存设置的限制。
直接内存和（操作系统）内存
虽然直接内存不受垃圾回收管理。但是它依然是Java虚拟机从操作系统申请的。它可以用于高效的I/O操作，如果你想使用直接内存空间可以使用这个方法：ByteBuffer.allocateDirect() 。
类的链接过程
接下来我们看下链接的过程，链接分为三步：验证阶段，准备阶段，解析阶段。这个过程由类加载子系统来完成，我们来看下：
验证阶段
JVM 读取类文件后，需要对其进行验证，确保这个类文件满足 JVM规范要求，不会有安全问题。
准备阶段
JVM 为类的静态变量分配内存，并且为它们设置默认值。在我们的 Building 类中，constructionYear 就是一个静态变量，所以它会在这个阶段被初始化为 0（对于 int 类型，初始化默认值为 0）。静态变量是属于类的，我们会把它放在元空间中，你看： 
解析阶段
JVM 将类的二进制数据中的符号引用 替换为直接引用 。这个过程是在元空间完成的。符号引用就是一组符号来描述所引用的目标，直接引用就是直接指向目标的指针、相对偏移量或者是一个能直接定位到目标的句柄。 直接引用好理解，符号应用是啥？以Building为例，符号引用就是：org.kfaino.jvm.Building.construct:()Lorg/kfaino/jvm/Building; 这两个东西都在元空间的运行时常量池中，你看：
类的初始化阶段
在讲类初始化之前，我们应该要知道类什么时候开始初始化，什么时候又不初始化？这里也是面试的常考题，我们来重点分析下。
类什么时候不初始化？
我直接以代码举例，你可以看下：
java
static String CONSTANT = "我是静态常量，我要被放到堆的常量池里面了";
static int i = 128;这里展示了两种情况，引用类型的String会被放到堆的字符串常量池中 ，而int类型则会被放在上面的元空间的静态变量中，你可以结合上面的图理解。接下来，我们看下初始化的情况。
类什么时候开始初始化？
还是以代码举例，你可以看下：
java
Building building = new Building();
Building.静态方法();
// 如果initializeBoolean为false也不会初始化
Class<?> clazz = Class.forName("org.kfaino.jvm.Building");
// 作为父类的情况
class SubBuilding extends Building {}看完这些初始化的情况之后，我们来看下具体是怎么初始化的。
类的初始化
初始化阶段首先会为对象分配内存 ，内存分配完成后，需要将分配给对象的内存空间都初始化为零值（分配零值 ）。然后设置对象头 。分配内存好理解，因为当Class被加载进元空间中就已经可以算出每个类型的内存大小了。至于对象头 ，我打算在垃圾回收时为你讲解，限于篇幅，这里按下不表。 这里的分配零值也有可考的内容，你看：
java
public class ZeroTest {
int i;
public void testMethod() {
int j;
System.out.println(i);
// Variable 'j' might not have been initialized
System.out.println(j);
}
}因为i在初始化时有分配0，所有可以正常输出。但是j是局部变量，没有初始化就会报错。
做完这三件事之后，JVM 会执行类的初始化代码。对于 Building 类来说，constructionYear 在这个阶段会被初始化为 2023，这个值是在类的静态初始化器（<clinit>）中设置的。 我在上篇文章中说到：如果我们在多线程中使用类加载器，可能会导致类被重复加载多次。除了会浪费资源外，还会导致我们一些静态初始化代码被执行多次。 指的就是<clinit> 。有关也有一个常见的面试题，我为你展示代码，你暂停思考下，结果如何：
java
public class Building {
static int constructionYear = 2023;
static {
constructionYear = 2024;
}
public static void main(String[] args) {
System.out.println(constructionYear);
}
}想好了吗？最终答案是2024。因为静态变量和静态代码块会放在静态初始化器中按顺序执行的。
使用
在完成初始化后，类就可以被应用程序正常使用了。当你调用一个方法时，JVM会为这个方法创建一个新的栈帧，并压入到当前线程的Java栈中。Java栈是线程私有的内存区域，用于存储每个方法调用的状态，包括局部变量、操作数栈、动态链接等信息。
方法调用
方法调用具体过程是什么样的呢？ 依然以 Building 为例， 我i先改造下它，加上一个计算建筑年龄的方法，你看：
java
public class Building {
private static final int CONSTRUCTION_YEAR = 1998;
public int calculateAge(int currentYear) {
return currentYear - CONSTRUCTION_YEAR;
}
}接下来，假设有一段代码调用了 calculateAge 方法：
java
public static void main(String[] args) {
Building building = new Building();
int age = building.calculateAge(2023);
}当 calculateAge 方法被调用时，我们来看下在JVM虚拟机内存发生了什么？为了方便你理解， 我事先画了一张图，你看： 
我在图中完整标注出执行顺序，你可以暂停看下。接下来我详细的为你解释：
- 方法调用：当Java代码执行到
building.calculateAge(2023)时，首先JVM会通过对象引用（即building）查找到类Building，然后在类中查找calculateAge方法的符号引用。 - 动态链接：JVM会根据
Building类中的符号引用找到calculateAge方法在运行时常量池 中的直接引用，获取改方法的内存地址。 - 创建新的栈帧：JVM为调用的方法创建一个新的栈帧，并推入当前线程的Java栈顶。这个栈帧包含局部变量表、操作数栈、动态链接和方法出口。
- 初始化局部变量表：JVM将方法调用的参数（即
currentYear和this）存储到新栈帧的局部变量表中。 - 更新程序计数器：JVM的程序计数器更新为
calculateAge方法的第一条字节码指令。 - 执行方法体： JVM开始执行
calculateAge方法的字节码。当执行到currentYear - CONSTRUCTION_YEAR时，它会将currentYear和CONSTRUCTION_YEAR推入操作数栈，然后执行减法操作，并将结果推入操作数栈顶。 - 方法返回：执行完
calculateAge方法后，JVM将操作数栈顶的结果（即年龄）作为方法返回值，并将calculateAge方法的栈帧从Java栈中弹出。 - 接收返回值：
calculateAge方法的返回值被推入调用者（即main方法）的操作数栈中，并赋值给局部变量age。 - 更新程序计数器：JVM的程序计数器更新为
main方法的下一条指令。
至此，我们就完成了从类的加载，到类的实例化，再到类的使用完整的过程。在这个过程中，你可以看到JVM运行时数据区 的各个部分是如何协同工作的。细心体会之后，你会发现类的加载和初始化阶段主要与元空间有关，而类的实例化阶段主要与堆有关。顺便我画了一张图，你可以看一下： 
接下来我们来看下类不用之后如何被卸载。
卸载
垃圾回收
当Building对象不再被任何引用变量引用时（对象不可达），它就成为了垃圾。在某个时间点，垃圾收集器会回收这个对象占用的堆内存，这块我将在后续的垃圾回收为你详细讲解。
类的完全卸载
如果Building类的ClassLoader实例被回收，且没有任何线程在Building类的方法内执行，且没有任何Java栈帧持有Building类的方法的引用，那么JVM会判断Building类可以被卸载，并可能在未来的某个时间点，由垃圾收集器回收其在元空间 内占用的内存。对，你没听错。方法区也可以进行垃圾回收。但是，类的完全卸载是一件苛刻的事情，你还记得我在第一篇文章中说的AppClassLoader吗？它是由BootstrapClassLoader创建，它的生命周期与JVM一样长，不会被垃圾回收。所以由AppClassLoader创建的类不会被卸载。当然，如果你想要卸载类，可以用第二篇文章中的自定义类加载器。
文中重要部分解析
初始化和未初始化
我在前面强调：什么时候会进行类的初始化阶段，什么会只进行加载和链接 。知道这两个差异有什么用呢？我们在编写代码的时候可以减少内存开销 ，我们现在知道类的初始化阶段需要分配内存 ，如果我们写一个懒加载，在使用时才初始化，那么我们的内存就会减少很多。相信你已经明白它的价值了。当然，空有概念没有代码可不行，我为你举一个例子，你可以看下：
java
public class ConfigManager {
private Map<String, Supplier<Config>> allConfigs = new HashMap<>();
public ConfigManager() {
// 在初始化阶段，只是将配置类的构造函数注册到map中
allConfigs.put("config1", Config1::new);
allConfigs.put("config2", Config2::new);
// ...
allConfigs.put("configN", ConfigN::new);
}
public Config getConfig(String name) {
return allConfigs.get(name).get();
}
}相比原来new的操作，我使用了Config1::new。它不会在一开始就被初始化，而是在我们getConfig()的时候，才进行初始化。这就是专家 级和普通级别程序员的差距。
直接内存VSJVM内存
我在之前为你提到：ByteBuffer.allocateDirect() 方法，它可以使用直接内存。用直接内存有什么好处？答案是可以减少内存复制的开销 ，直接缓冲区可以直接在内存中进行数据操作，无需将数据复制到Java堆内存中。还是老规矩，我用代码为你演示一个读取文件IO的场景，你看：
java
// 一个5G的视频
private static final String FILE_PATH = "C:\\Users\\xxx\\Desktop\\1.mp4";
// 1MB
private static final int BUFFER_SIZE = 1024 * 1024;
public static void main(String[] args) throws Exception {
// 我用了懒加载
testBufferAllocator(ByteBuffer::allocate, "Heap Buffer");
testBufferAllocator(ByteBuffer::allocateDirect, "Direct Buffer");
}
private static void testBufferAllocator(BufferAllocator allocator, String testName) throws Exception {
try (FileChannel channel = FileChannel.open(Paths.get(FILE_PATH), StandardOpenOption.READ)) {
ByteBuffer buffer = allocator.allocate(BUFFER_SIZE);
Instant start = Instant.now();
while (channel.read(buffer) > 0) {
buffer.clear();
}
Instant end = Instant.now();
System.out.printf("%s: %s ms%n", testName, Duration.between(start, end).getNano() / 1000000);
}
}
private interface BufferAllocator {
ByteBuffer allocate(int capacity);
}我分别用堆缓存 和直接缓存来测试它们两个的吞吐量。我们来看下结果：
java
Connected to the target VM, address: '127.0.0.1:5061', transport: 'socket'
Heap Buffer: 934 ms
Direct Buffer: 765 ms
Disconnected from the target VM, address: '127.0.0.1:5061', transport: 'socket'
Process finished with exit code 0直接内存比堆内存快了将近200ms。这两种内存的差距就在于堆内存多出了数据从内核缓冲区复制到Java堆内存中的缓冲区步骤。
关于intern()方法
我在上面说到，String类型的静态变量 会被放到堆的字符串常量池中。它的目的就是为了减少相同字符串初始化带来的开销。当然，这样的设计就会带来一个问题。你来看下这段代码：
java
String s1 = "Building";
String s2 = new String("Building");
System.out.println(s1 == s2);
System.out.println(s1 == s2.intern()); 输出结果是多少呢？暂停思考下，有答案了你再接着往下看
我来公布答案：第一个为false ，因为 s2 是一个新的字符串实例：第二个为true，因为 s2.intern() 返回的是字符串常量池中的 "Hello"；
如果你感兴趣还可以阅读官方文档，我对相关部分进行了截图，你可以看下，链接已放在参考文献中，如果你感兴趣，也可以阅读。 
总结
至此，本篇完结。我们来回顾一下：本篇文章是类加载过渡到JVM内存结构的衔接文章。为了让你把之前的知识串起来，我结合了内存结构重新为你讲解类的生命周期。希望看完这篇文章，你会有不一样的收获。
参考文献
后续
本篇文章从类的完整生命周期的角度为你深入解析了JVM内存结构，但仍有一些细节未涉及，例如：本地方法栈的具体工作方式，以及本地方法是C++代码，它是如何运作的？在接下来的文章中，我将进一步展开，为你勾勒出JVM内存结构的全貌，让你对其有更深入、全面的理解。敬请继续关注！