Java虚拟机（JVM）的架构和工作原理，字节码执行流程

纣王家子迎新

已于 2024-08-30 23:37:30 修改

阅读量767

点赞数 30

分类专栏： java 文章标签： java jvm 架构字节码执行流程 jvm工作原理

于 2024-08-30 23:35:39 首次发布

本文链接：https://blog.csdn.net/WZX17307935391/article/details/141728914

版权

java 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

JVM的概念

JVM是Java Virtual Machine的缩写，即Java虚拟机，也被称为Java程序运行的核心环境 。它是一种用于计算设备的规范，‌通过在实际的计算机上仿真模拟各种计算机功能来实现。‌JVM由一套字节码指令集、‌一组寄存器、‌一个栈、‌一个垃圾回收堆和一个存储方法域等组成。‌它屏蔽了与操作系统平台相关的信息，使得Java程序只需生成在JVM上运行的目标代码（字节码），即可在多种平台上的JVM不加修改地运行。这是Java实现“一次编译，到处运行”的关键。JVM在执行字节码时，会将其解释成具体平台上的机器指令执行。

JVM的架构

JVM主要由以下几个部分组成：

类加载器

类加载器的概念

类加载器是JVM的一个重要组成部分，它实现了Java的动态加载特性。负责将Java类的字节码文件（.class文件）加载到位于内存的JVM中，并转换为运行时数据结构，为程序的执行做好准备。

类加载器的实质

类加载器负责实现类的加载过程，JVM是在内存中运行的。当Java程序被编译成字节码（.class文件）后，这些字节码不会直接在物理硬件上执行，而是被JVM加载到内存中，并由JVM的解释器或即时编译器（JIT Compiler）转换为对应平台的机器码后执行。这个过程实现了Java的“一次编写，到处运行”的特性，因为JVM为不同操作系统平台提供了统一的运行环境。

JVM的类加载机制

JVM的类加载机制是Java虚拟机（JVM）中一个非常核心且复杂的部分，它负责将类的字节码文件加载到内存中，并初始化为JVM可以直接使用的数据结构。下面我将详细说明JVM的类加载机制，主要分为几个关键阶段：加载、验证、准备、解析和初始化。

1. 加载（Loading）

加载阶段是类加载机制的第一个阶段。在这一阶段，JVM会查找并加载类的二进制数据，通常是类的.class文件。这些文件可以通过不同的途径被获取，如文件系统、网络、ZIP/JAR包等。加载完成后，JVM会在内存中生成一个代表这个类的java.lang.Class对象，这个对象作为类数据的访问入口。

2. 验证（Verification）

验证阶段的主要目的是确保加载的类信息是符合JVM规范的，没有潜在的安全问题。验证过程包括文件格式验证、元数据验证、字节码验证和符号引用验证等步骤。通过这些验证，JVM可以确保类文件的正确性和安全性。

3. 准备（Preparation）

准备阶段主要为类的静态变量分配内存，并设置其初始值。这里的初始值是指数据类型的默认值，如int的默认值是0，boolean的默认值是false等。但需要注意的是，这里设置的只是默认值，而非用户代码中定义的初始值。用户定义的初始值将在初始化阶段被赋予。

4. 解析（Resolution）

解析阶段是将类、接口、字段和方法的符号引用转换为直接引用的过程。符号引用是一组符号，用于描述所引用的目标，而直接引用则是指向目标的指针、偏移量或句柄等。通过解析，JVM可以确定每个符号引用的具体指向，为后续的执行阶段做准备。

5. 初始化（Initialization）

初始化阶段是类加载机制的最后一个阶段。在这一阶段，JVM会执行类的构造器<clinit>()方法，这个方法是由编译器自动生成的，用于初始化类的静态变量和执行静态代码块。需要注意的是，<clinit>()方法只会被执行一次，且多个线程同时访问时，JVM会确保只有一个线程执行该方法。

6.类加载器（Class Loaders）

JVM中还存在类加载器的概念，它负责实现类的加载过程。Java中的类加载器采用了一种双亲委派模型（Parents Delegation Model），即当一个类加载器需要加载一个类时，它首先会请求其父类加载器进行加载，如果父类加载器无法加载，则再由当前类加载器进行加载。这种模型有助于保证Java平台的安全性，防止用户自定义的类替换掉Java核心类库中的类。

JVM类加载机制中的“双亲委派模型”

使用“双亲委派模型”的原因

在Java中，类加载器（Class Loader）负责将类的字节码文件加载到JVM中，并将其转换成JVM可以直接使用的数据结构。为了确保Java平台的安全性和类的唯一性，Java采用了一种名为“双亲委派模型”的类加载机制。

“双亲委派模型”的概念

双亲委派模型的核心思想是：当一个类加载器（称为子加载器）需要加载一个类时，它首先不会尝试自己去加载这个类，而是将这个加载请求委派给它的父加载器（如果有的话）去完成。每个类加载器都是如此，只有当父加载器无法加载这个类时，子加载器才会尝试自己去加载。

使用“双亲委派模型”的好处：

安全性：Java的核心类库（如java.lang.*、java.util.*等）是由启动类加载器（Bootstrap ClassLoader）加载的，这些类在JVM启动时就被加载到内存中，并且无法被用户自定义的类加载器所替换。这样可以防止恶意代码通过自定义类加载器来替换核心类库中的类，从而破坏Java平台的安全性。
唯一性：由于类加载器之间的委托关系，Java中的每个类在JVM中都只会被加载一次，并且与它的类加载器相关联。这样就保证了类的唯一性，避免了因为类加载器的不同而导致相同全限定名的类被加载多次的问题。
沙箱安全机制：双亲委派模型还可以配合Java的沙箱安全机制（Sandbox Security Mechanism），为不同的应用程序提供隔离的运行环境，防止应用程序之间相互干扰。

注意：双亲委派模型并不是强制性的，用户可以通过自定义类加载器来打破这个模型，但这需要谨慎操作，以避免引入安全问题和类加载冲突。

“双亲委派模型”伪代码示例

假设我们有两个自定义的类加载器：ChildClassLoader 和 ParentClassLoader，其中 ChildClassLoader 是 ParentClassLoader 的子类。我们将模拟类加载过程，并展示当 ChildClassLoader 尝试加载一个类时，它是如何首先委派给 ParentClassLoader 的。

// 假设的ParentClassLoader类
class ParentClassLoader extends ClassLoader {
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        // 首先，检查该类是否已经被加载
        Class<?> clazz = findLoadedClass(name);
        if (clazz != null) {
            return clazz;
        }
        
        // 尝试从父类加载器（这里简化为系统类加载器）加载
        try {
            clazz = getParent().loadClass(name);
            return clazz;
        } catch (ClassNotFoundException e) {
            // 如果父类加载器加载不到，再尝试自己加载
        }
        
        // 这里应该添加自己加载类的逻辑，但为简化起见，我们直接抛出异常
        throw new ClassNotFoundException("Class " + name + " not found.");
    }
}

// 假设的ChildClassLoader类
class ChildClassLoader extends ParentClassLoader {
    // 通常ChildClassLoader不需要重写loadClass方法，
    // 因为它已经继承了ParentClassLoader的loadClass实现，
    // 该实现已经遵循了双亲委派模型。
    // 但为了展示，我们可以保持这个类为空，或者添加一些特定的初始化逻辑。
}

// 使用示例
public class ClassLoaderDemo {
    public static void main(String[] args) {
        // 创建ChildClassLoader实例
        ClassLoader childClassLoader = new ChildClassLoader();
        
        try {
            // 尝试加载一个类，比如java.lang.String
            // 注意：在实际应用中，不应该尝试加载Java核心库中的类，
            // 这里只是为了演示双亲委派模型。
            Class<?> clazz = childClassLoader.loadClass("java.lang.String");
            
            // 如果没有异常，说明类被成功加载了。
            // 但实际上，这个类是由启动类加载器（Bootstrap ClassLoader）加载的，
            // 而不是由我们的ChildClassLoader或ParentClassLoader。
            // 这里只是为了说明双亲委派的过程。
            
            System.out.println("Class loaded successfully: " + clazz.getName());
        } catch (ClassNotFoundException e) {
            System.out.println("Class not found: " + e.getMessage());
        }
    }
}

// 注意：上面的示例代码并不完全准确，因为实际上java.lang.String是由启动类加载器加载的，
// 它不是通过自定义的类加载器链来加载的。但这里只是为了演示双亲委派的概念。

在这个例子中，ChildClassLoader 尝试加载 java.lang.String 类时，它会首先将其加载请求委派给它的父加载器 ParentClassLoader，而 ParentClassLoader 又会进一步将其委派给它的父加载器（在这个简化的例子中，我们假设它直接委派给了系统类加载器，但在实际的JVM中，它最终会委派给启动类加载器）。由于 java.lang.String 是Java核心库中的类，因此它会被启动类加载器加载，而不是由我们的自定义类加载器加载。这个过程体现了双亲委派模型的工作原理。

运行时数据区：

程序计数器：

每个线程都有一个独立的程序计数器，用于指示当前线程正在执行的字节码指令的地址。

Java虚拟机栈：

每个线程在创建时都会创建一个虚拟机栈，用于存储局部变量表、操作数栈、动态链接、方法出口等信息。

本地方法栈：

与虚拟机栈类似，但它是为执行本地方法（如C语言编写的方法）服务的。

Java堆：

JVM中内存最大的一块，被所有线程共享，用于存放对象实例和数组。

方法区：

在Java 8之前，方法区包含运行时常量池，用于存储类的结构信息、常量、静态变量等。Java 8之后，方法区被元空间（Metaspace）所替代，元空间使用本地内存而非JVM堆内存。

执行引擎：

负责执行字节码指令，包括解释执行和即时编译（JIT）两种方式。解释执行是指逐条解释字节码指令并执行，而JIT编译则是将部分字节码编译成机器码以提高执行效率。

垃圾回收器：

负责回收JVM中不再使用的对象，释放内存空间。垃圾回收器是JVM的一个重要组成部分，它采用多种算法来识别和回收垃圾对象。

JVM的工作原理

JVM的工作原理可以概括为以下几个步骤：

代码编译：Java源代码被编译成Java字节码，这是JVM能够识别的指令集。
类加载：JVM通过类加载器将字节码文件加载到内存中，并转换为运行时数据结构。
字节码验证：JVM对加载的字节码进行验证，确保它符合JVM规范，没有安全漏洞。
执行：JVM的执行引擎负责执行字节码指令。根据JVM的实现，可以选择解释执行或JIT编译执行。
内存管理：JVM负责管理Java程序执行过程中所使用的内存，包括堆、栈、方法区等。
垃圾回收：JVM的垃圾回收器定时回收不再使用的对象，释放内存空间。

常见JVM调优方法：

堆内存调优：

调整JVM的堆内存大小，包括初始堆大小（-Xms）和最大堆大小（-Xmx）。合理的堆内存设置可以避免因内存不足导致的性能问题，同时减少因内存过大造成的资源浪费。
通过设置新生代（Young Generation）和老年代（Old Generation）的大小，以及Eden区与 Survivor区的比例，优化垃圾回收（GC）的效率和内存利用率。

垃圾回收（GC）调优：

选择合适的垃圾回收器，如Serial GC、Parallel GC、CMS GC或G1 GC。不同的垃圾回收器适用于不同的应用场景，例如，G1 GC适用于需要低延迟和可预测停顿时间的应用。
调整垃圾回收器的相关参数，如新生代大小、老年代大小、GC线程数等，以优化垃圾回收的性能。

线程调优：

合理设置线程池的大小，避免创建过多的线程导致系统资源耗尽。
调整线程栈的大小，以适应应用程序的需求。线程栈过大可能导致内存浪费，过小则可能导致栈溢出错误。

JIT编译器调优：

通过调整JIT编译器的参数，如编译阈值、内联策略等，优化热点代码的执行效率。
合理使用JIT编译器的优化技术，如逃逸分析、标量替换等，提高代码的执行速度。

类加载调优：

优化类加载器的层次结构和加载策略，减少类加载的次数和提高加载速度。
使用自定义的类加载器来隔离不同的组件或库，避免类冲突和内存泄漏。

I/O调优：

使用合适的缓冲区大小和优化I/O操作方式（如NIO），减少I/O操作的次数和开销。
对于高并发I/O操作，考虑使用异步I/O或NIO的多路复用机制来提高性能。

监控和日志分析：

使用JVM监控工具（如JConsole、VisualVM、JProfiler等）对应用程序进行实时监控，分析内存使用、GC行为、线程状态等关键指标。
启用GC日志记录，并通过分析GC日志来识别性能瓶颈和优化点。

代码优化：

优化Java代码，减少不必要的对象创建和销毁，降低垃圾回收的压力。
使用合适的集合类型和算法，提高代码的执行效率。
避免在循环中创建大量对象或进行复杂的计算。

在Java代码中减少不必要的对象创建

重用对象：

当对象可以被多次使用时，考虑重用它们而不是每次都创建新的实例。例如，在循环中，可以将对象声明在循环外部，并在循环内部重复使用。

使用对象池：

对于创建成本较高的对象（如数据库连接、线程等），可以使用对象池来管理它们的生命周期。对象池可以减少对象的创建和销毁次数，从而提高性能。

避免在方法中创建不必要的对象：

在方法内部，尽量避免创建仅在方法内部使用的临时对象，特别是当这些对象可以在方法调用之间共享时。

使用字符串常量：

对于字符串常量，应该使用String的intern()方法或直接在代码中使用字符串字面量，以便在JVM的字符串常量池中重用相同的字符串对象。

利用基本数据类型：

当可以使用基本数据类型（如int、double等）时，避免使用它们的包装类（如Integer、Double等），因为包装类的创建和拆箱操作会带来额外的性能开销。

优化集合的使用：

在使用集合时，根据实际需求选择合适的集合类型，并合理设置集合的初始容量和加载因子，以减少扩容时的对象创建。

避免在循环中创建对象：

尽可能将循环中创建的对象移到循环外部，如果对象必须在循环中创建，考虑是否可以使用同一个对象并更新其状态。

使用不可变对象：

不可变对象一旦被创建，其状态就不能被改变，因此它们可以被安全地共享而无需担心数据一致性问题。使用不可变对象可以减少对象的创建和复制次数。

利用缓存：

对于计算结果或对象，如果它们可以被缓存并在后续请求中重用，那么使用缓存可以显著减少对象的创建和计算开销。

分析并优化热点代码：

使用性能分析工具（如JProfiler、VisualVM等）来识别性能瓶颈和热点代码。针对这些热点代码进行优化，减少不必要的对象创建和内存分配。

字节码执行流程

加载类文件

类装载器：负责将Java类文件（.class文件）加载到JVM中。在这个过程中，类装载器会验证类文件是否符合Java类文件格式规范。
加载到JVM：类文件被加载后，JVM会为其创建一个Class对象，并存储在方法区（或元空间，从JDK 8开始）中。

字节码校验

字节码校验器：对加载的类文件中的字节码进行校验，确保代码中不包含非法操作，如访问违规内存、执行不安全的系统调用等。这是JVM实现安全性的重要环节。

解释执行

解释器：如果字节码通过了校验，JVM的解释器会逐条解释执行字节码指令。解释器会将字节码转换为机器码，然后交由底层操作系统执行。
即时编译器：为了提高执行效率，JVM还包含了一个即时编译器。JIT编译器会在运行时将热点代码（即频繁执行的代码）编译成机器码，以提高执行速度。

运行时数据区

在执行过程中，JVM会利用运行时数据区来存储和管理程序运行时的数据，即在执行过程中，JVM的内存管理器负责分配和回收内存。

垃圾回收

当对象不再被引用时，JVM的垃圾回收器会回收其占用的内存空间。

程序结束

当Java程序执行完毕或遇到异常终止时，JVM会卸载已加载的类并释放所有资源。