深入理解JVM类加载机制：从new Object()到初始化的完整生命周期解析

一旅人
363 阅读12分钟

当我们编写 new Object() 时，JVM 背后到底发生了怎样的故事？类加载过程中的初始化阶段究竟暗藏哪些玄机？揭秘Java类加载过程中的关键阶段与初始化顺序的底层原理

一、引言：从一段简单代码说起

先来看一个看似简单的 Java 代码片段：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

当我们执行这段代码时，背后却隐藏着 JVM 复杂的类加载机制。.java 文件经过编译变成 .class 字节码文件，这些"静态"的字节码需要被 JVM 动态地加载、处理并最终执行。这就是类加载过程的神奇之处。

类加载机制是 Java 语言的核心基石，它赋予了 Java "一次编写，到处运行" 的能力。理解这一过程，能帮助我们编写更高效的代码。

二、类生命周期：七个阶段的完整旅程

在深入类加载过程之前，我们先来了解类的完整生命周期。一个类在 JVM 中从加载到卸载，总共经历七个阶段：

阶段描述是否必须特点JVM规范要求
加载(Loading)查找并加载类的二进制数据是将字节码读入内存，生成Class对象强制
验证(Verification)确保被加载的类正确无误是安全验证，防止恶意代码强制
准备(Preparation)为类变量分配内存并设置初始零值是注意：不是程序员定义的初始值强制
解析(Resolution)将符号引用转换为直接引用否可以在初始化后再进行可选
初始化(Initialization)执行类构造器 <clinit>() 方法是初始化类而不是对象强制
使用(Using)正常使用类的功能是类的使命阶段-
卸载(Unloading)从内存中释放类数据否由垃圾回收器负责可选

前五个阶段（加载、验证、准备、解析、初始化）统称为类加载过程。

三、类生命周期的七个步骤详解

3.1 加载阶段：寻找类的旅程

加载阶段是类加载过程的起点，主要完成三件事情：

  1. 通过类的全限定名获取定义此类的二进制字节流
  2. 将这个字节流所代表的静态存储结构转换为方法区的运行时数据结构
  3. 在内存中生成一个代表这个类的 java.lang.Class 对象，作为方法区这个类的各种数据的访问入口
// 示例：不同的类加载方式
public class LoadingExample {
    public static void main(String[] args) throws Exception {
        // 通过类加载器加载
        Class<?> clazz1 = ClassLoader.getSystemClassLoader().loadClass("java.lang.String");
        
        // 通过Class.forName加载（默认会初始化）
        Class<?> clazz2 = Class.forName("java.lang.String");
        
        // 通过字面常量获取（不会触发初始化）
        Class<?> clazz3 = String.class;
        
        // new对象时，类未加载的话会触发类加载机制
        LoadingExample instance = new LoadingExample();
        
        System.out.println("三种方式加载的类是否相同: " + 
                          (clazz1 == clazz2 && clazz2 == clazz3));
    }
}

3.2 验证阶段：安全的第一道防线

验证阶段确保 Class 文件的字节流中包含的信息符合《Java虚拟机规范》的全部约束要求，保证这些信息不会危害虚拟机自身的安全。

验证类型验证内容失败后果
文件格式验证魔数（0xCAFEBABE）、版本号、常量池ClassFormatError
元数据验证语义验证、继承关系（如是否实现抽象方法）IncompatibleClassChangeError
字节码验证逻辑验证、跳转指令合法性VerifyError
符号引用验证引用真实性、访问权限（如访问private方法）NoSuchFieldError、NoSuchMethodError

3.3 准备阶段：零值初始化的奥秘

这是最容易产生误解的阶段！ 在准备阶段，JVM 为类变量（static修饰的变量)分配内存并设置初始零值，注意这不是程序员定义的初始值。

public class PreparationExample {
    // 准备阶段后 value = 0，而不是 100
    public static int value = 100;
    
    // 准备阶段后 constantValue = 200（因为有final修饰）
    public static final int constantValue = 200;
    
    // 实例变量 - 准备阶段完全不管
    public int instanceValue = 300;
}

各种数据类型的零值对照表：

数据类型零值数据类型零值
int0booleanfalse
long0Lfloat0.0f
double0.0char'\u0000'
引用类型nullshort(short)0

关键区别：只有类变量（static变量）在准备阶段分配内存和初始化零值，实例变量会在对象实例化时随对象一起分配在堆内存中。

3.4 解析阶段：符号引用到直接引用的转换

解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。这个过程可以在初始化之后再进行，这是为了支持Java的动态绑定特性。

解析主要针对以下四类符号引用：

引用类型解析目标可能抛出的异常
类/接口解析将符号引用解析为具体类/接口NoClassDefFoundError
字段解析解析字段所属的类/接口NoSuchFieldError
方法解析解析方法所属的类/接口NoSuchMethodError
接口方法解析解析接口方法所属的接口AbstractMethodError

解析阶段：其实可以简单理解为就是将一组JVM所定义的字面量，转化为具体的指针或者偏移量。

3.5 初始化阶段：执行类构造器 <clinit>()

这是类加载过程的最后一步，也是真正开始执行类中定义的Java程序代码的一步。

初始化阶段就是执行类构造器 <clinit>() 方法的过程，该方法由编译器自动收集类中的所有类变量（static 成员变量）的赋值动作和静态代码块（static {} 块）中的语句合并生成，其本质是 JVM 为类的静态变量赋予程序设定的初始值（而非默认值），并执行静态初始化代码，从而完成类资源的初始化。

JVM规范严格规定的六种初始化触发情况：

  1. 遇到new、getstatic、putstatic或invokestatic这四条字节码指令时

    // new指令 - 创建类的实例
Object obj = new Object();

// getstatic指令 - 读取类的静态字段
int value = MyClass.staticField;

// putstatic指令 - 设置类的静态字段  
MyClass.staticField = 100;

// invokestatic指令 - 调用类的静态方法
MyClass.staticMethod();

  2. 使用java.lang.reflect包的方法对类进行反射调用时

    // 反射调用会触发类的初始化
Class<?> clazz = Class.forName("com.example.MyClass");

  3. 当初始化一个类时，发现其父类还没有进行过初始化

    class Parent {
    static { System.out.println("Parent初始化"); }
}

class Child extends Parent {
    static { System.out.println("Child初始化"); }
}
// 初始化Child时会先初始化Parent

  4. 虚拟机启动时，用户指定的主类（包含main()方法的那个类）

    // 执行 java MyApp 时，MyApp类会被初始化
public class MyApp {
    public static void main(String[] args) {
        System.out.println("应用程序启动");
    }
}

  5. 使用JDK7新加入的动态语言支持时

    // 使用MethodHandle等动态语言特性
MethodHandles.Lookup lookup = MethodHandles.lookup();

  6. 一个接口中定义了JDK8新加入的默认方法时，如果这个接口的实现类发生了初始化，要先将接口进行初始化

    interface MyInterface {
    // JDK8默认方法会触发接口初始化
    default void defaultMethod() {
        System.out.println("默认方法");
    }
}

3.6 使用阶段：类的使命实现

当类完成初始化后，就进入了使用阶段。这是类生命周期中最长的阶段，类的所有功能都可以正常使用：

public class UsageStageExample {
    public static void main(String[] args) {
        // 类已完成初始化，进入使用阶段
        MyClass obj = new MyClass();  // 创建对象实例
        obj.instanceMethod();         // 调用实例方法
        MyClass.staticMethod();       // 调用静态方法
        int value = MyClass.staticVar;// 访问静态变量
    }
}

class MyClass {
    public static int staticVar = 100;
    public int instanceVar = 200;
    
    public static void staticMethod() {
        System.out.println("静态方法");
    }
    
    public void instanceMethod() {
        System.out.println("实例方法");
    }
}

在使用阶段，类可以：

  • 创建对象实例
  • 调用静态方法和实例方法
  • 访问和修改静态字段和实例字段
  • 被其他类引用和继承

3.7 卸载阶段：生命的终结

类的卸载是生命周期的最后阶段，但并不是必须发生的。一个类被卸载需要满足以下条件：

  1. 该类所有的实例都已被垃圾回收
  2. 加载该类的ClassLoader已被垃圾回收
  3. 该类对应的java.lang.Class对象没有被任何地方引用
public class UnloadingExample {
    public static void main(String[] args) throws Exception {
        // 使用自定义类加载器加载类
        CustomClassLoader loader = new CustomClassLoader();
        Class<?> clazz = loader.loadClass("com.example.TemporaryClass");
        
        // 创建实例并使用
        Object instance = clazz.newInstance();
        System.out.println("类已加载并使用: " + clazz.getName());
        
        // 解除所有引用，使类和类加载器可被回收
        clazz = null;
        instance = null;
        loader = null;
        
        // 触发GC，可能卸载类
        System.gc();
        System.out.println("类和类加载器可能已被卸载");
    }
}

class CustomClassLoader extends ClassLoader {
    // 自定义类加载器实现
}

所以，在 JVM 生命周期内，由 jvm 自带的类加载器加载的类是不会被卸载的。但是由我们自定义的类加载器加载的类是可能被卸载的。

四、关键辨析：类初始化 vs. 对象实例化

这是本文的核心观点，也是大多数开发者容易混淆的概念。让我们通过一个对比表格来清晰区分：

特性类初始化 (Initialization)对象实例化 (Instantiation)
触发时机类被首次"主动使用"时（JVM控制）遇到new关键字时（程序员控制）
发生次数一次（每个类加载器范围内）多次（可以创建多个对象实例）
核心方法<clinit>()方法<init>()方法（构造函数）
操作目标类本身（初始化静态变量/类变量）对象实例（初始化实例变量）
内存区域方法区（元空间）Java堆
执行内容静态变量赋值、静态代码块实例变量赋值、实例代码块、构造函数

五、深度实战：初始化顺序全面解析

现在，让我们通过一个综合示例来回答开篇的思考题：如果一个类同时包含静态变量、静态代码块、实例变量、实例代码块和构造方法，它们的执行顺序是怎样的？在存在继承关系时又会如何变化？

5.1 单类初始化顺序

public class InitializationOrder {
    // 静态变量
    public static String staticField = "静态变量";
    
    // 静态代码块
    static {
        System.out.println(staticField);
        System.out.println("静态代码块");
    }
    
    // 实例变量
    public String field = "实例变量";
    
    // 实例代码块
    {
        System.out.println(field);
        System.out.println("实例代码块");
    }
    
    // 构造方法
    public InitializationOrder() {
        System.out.println("构造方法");
    }
    
    public static void main(String[] args) {
        System.out.println("第一次实例化:");
        new InitializationOrder();
        
        System.out.println("\n第二次实例化:");
        new InitializationOrder();
    }
}

输出结果：

静态变量
静态代码块
第一次实例化:
实例变量
实例代码块
构造方法

第二次实例化:
实例变量
实例代码块
构造方法

关键发现：

  1. 静态变量/代码块只在类第一次加载时执行一次
  2. 实例代码块在每次创建对象时都会执行
  3. 执行顺序：静态变量/代码块 → 实例变量/代码块 → 构造方法

注意⚠️：同类中，静态变量 / 静态代码块、实例变量 / 实例代码块的执行顺序，取决于它们在类中定义的先后位置，而非 “变量一定优先于代码块

5.2 继承关系下的初始化顺序

class Parent {
    // 父类静态变量
    public static String parentStaticField = "父类静态变量";
    
    // 父类静态代码块
    static {
        System.out.println(parentStaticField);
        System.out.println("父类静态代码块");
    }
    
    // 父类实例变量
    public String parentField = "父类实例变量";
    
    // 父类实例代码块
    {
        System.out.println(parentField);
        System.out.println("父类实例代码块");
    }
    
    // 父类构造方法
    public Parent() {
        System.out.println("父类构造方法");
    }
}

class Child extends Parent {
    // 子类静态变量
    public static String childStaticField = "子类静态变量";
    
    // 子类静态代码块
    static {
        System.out.println(childStaticField);
        System.out.println("子类静态代码块");
    }
    
    // 子类实例变量
    public String childField = "子类实例变量";
    
    // 子类实例代码块
    {
        System.out.println(childField);
        System.out.println("子类实例代码块");
    }
    
    // 子类构造方法
    public Child() {
        System.out.println("子类构造方法");
    }
    
    public static void main(String[] args) {
        System.out.println("第一次实例化子类:");
        new Child();
        
        System.out.println("\n第二次实例化子类:");
        new Child();
    }
}

输出结果：

父类静态变量
父类静态代码块
子类静态变量
子类静态代码块
第一次实例化子类:
父类实例变量
父类实例代码块
父类构造方法
子类实例变量
子类实例代码块
子类构造方法

第二次实例化子类:
父类实例变量
父类实例代码块
父类构造方法
子类实例变量
子类实例代码块
子类构造方法

关键发现：

  1. 父类静态变量/代码块 → 子类静态变量/代码块 → 父类实例变量/代码块 → 父类构造方法 → 子类实例变量/代码块 → 子类构造方法
  2. 父类优先于子类初始化

六、面试常见问题与解答

6.1 高频面试题解析

Q1: 下面代码的输出结果是什么？为什么？

public class InterviewQuestion {
    public static void main(String[] args) {
        System.out.println(Child.value);
    }
}

class Parent {
    static int value = 100;
    static { System.out.println("Parent静态代码块"); }
}

class Child extends Parent {
    static { System.out.println("Child静态代码块"); }
}

A: 输出结果为：

Parent静态代码块
100

解析： 通过子类引用父类的静态字段，不会导致子类初始化，这是类加载机制的一个重要特性。

七、总结与思考

通过本文的深入分析，我们可以总结出以下几个关键点：

类加载过程五个阶段：加载 → 验证 → 准备 → 解析 → 初始化，每个阶段都有其特定任务

关键区别：

  • 初始化阶段是初始化类(执行<clinit>())，而不是初始化对象（执行<init>()）
  • 类静态变量在准备阶段分配内存并设置零值，在初始化阶段赋实际值
  • 实例变量在对象实例化时分配内存和初始化

初始化顺序原则：

  • 父类优先于子类
  • 静态优先于实例
  • 变量定义顺序决定初始化顺序
avatar
文章
阅读
粉丝