JVM基础系列：JVM 类加载机制

有时候面试的时候，会遇到给你一串代码，里面有很多打印语句，让你说出打印的顺序其实就是在考察JVM 类加载机制。

JVM 虚拟机执行 class 字节码的过程可以分为七个阶段：加载、验证、准备(重点)、解析、初始化(重点)、使用、卸载。

　　这里最后会给出例子，现在先讲下这几个过程。

加载

官方描述：

加载阶段是类加载过程的第一个阶段。在这个阶段，JVM 的主要目的是将字节码从各个位置（网络、磁盘等）转化为二进制字节流加载到内存中，接着会为这个类在 JVM 的方法区创建一个对应的 Class 对象，这个 Class 对象就是这个类各种数据的访问入口。

就是代码生成的字节码数据加载到内存中。

验证

JVM加载完Class字节码文件，并在方法区创建对应的Class对象之后，便会对字节码流做验证，只有符合JVM字节码规范的文件才能被JVM正确执行，校验大概分为以下几个类型：

JVM规范校验。JVM 会对字节流进行文件格式校验，判断其是否符合 JVM 规范，是否能被当前版本的虚拟机处理。例如：文件是否是以 0x cafe babe开头，主次版本号是否在当前虚拟机处理范围之内等。(这种基本上不会有问题)

代码逻辑校验。JVM 会对代码组成的数据流和控制流进行校验，确保JVM运行该字节码二五年间不会出现致命问题。简单举例，一个方法需要传入int整型参数，但是代码里却传入String类型，一个方法返回String类型，但是最后没有返回结果，代码中引用一个名位Apple的类，但是实际上没有定义apple类。（正常情况下，我们写代码用编译器，会提示这些错误，不会到JVM这一层）

准备（重点）

当完成字节码文件加载和校验之后，JVM便会开始为类变量分配内存并初始化，这里就需要注意两个关键点，既内存分配的对象以及初始化的类型。

- 对象的内存分配。Java中变量有“类变量”和“类成员变量”两种类型，“类变量”是指被static修饰的变量，而所有其他类型的变量就都属于”类成员变量“。在准备阶段，JVM只会为”类变量“分配内存，而不会为”类成员变量“分配内存，”类成员变量“的内存分配需要到初始化阶段才开始。

　　例如下面这段代码在准备阶段，只会为factor静态属性分配内存，而不会为website属性分配内存。

public static int factor = 3;
public String website = "hello web";

- 类型的初始化。在准备阶段，JVM会为类变量分配内存，并为其初始化。但是这里的初始化指的是变量赋予变量Java中此类型的零值（默认值），而不是用户代码里的值。

　　例如下面代码，在准备阶段之后，sector的值，应该是0，不是9 。

public static int sector = 3;

　　但是如果一个变量被 static final 修饰的话，那么在准备阶段，属性便会被赋予用户代码里的值，例如以下代码，在准备阶段后，number的值将会是3，而不是0.

public static final int number = 3;

　　之所以static final 会被直接赋值，其实我们稍微思考一下就明白了。

　　当被final修饰的变量，就是不可改变的意思，就是说number一旦赋值了就不会改变。那么就必须一开始就赋予用户想要好的值，因此final修饰的类变量在准备阶段就赋予想要的值，而没有被修饰的类变量，其值可能在初始化阶段或者运行阶段发送变化，搜易就没有必要再准备阶段对他赋予用户想要的值。

　　解析

　　当通过准备阶段之后，JVM针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用限定符7类引用进行解西，这个阶段的主要任务是将其在常量池中的符号引用替换成直接其在内存中的直接引用。这个阶段对我们来说几乎透明，了解下就行。

　　初始化（重点）

　　到了初始化阶段，用户定义的java程序代码才真正的开始执行，在这个阶段，JVM会根据语句执行顺序对类对象进行初始化，一般来说JVM遇到下面5种情况的时候回触发初始化：

遇到 new（实例化对象）、getstatic（获取静态值）、putstatic（设置静态值）、invokestatic（执行静态方法）这四条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。特殊的，被final修饰、已在编译器把结果放入常量池的静态字段除外。
使用java.long.reflect包的方法对类进行反射调用的时候，如果类没有进行初始化，则需要先触发其初始化。
当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
当虚拟机启动时，用户需要指定一个要执行的主类（需要包含main方法的类），JVM会先初始化这个类。
当使用 JDK1.7 动态语言支持时，如果一个 java.lang.invoke.MethodHandle实例最后的解析结果 REF_getstatic,REF_putstatic,REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行初始化，则需要先出触发其初始化。

　　上面几个条件可能还不是很明显，先了解下，后面用一些题目来巩固下。

　　使用

　　当JVM完成初始化阶段之后，JVM便开始从入口开始执行用户的程序代码，这个也是作为了解即可。

　　卸载

　　当用户程序代码执行完毕后，JVM 便开始销毁创建的 Class 对象，最后负责运行的 JVM 也退出内存。这个阶段也只是了解一下就可以。

　　看完了Java类的加载过程（加载、验证、准备、解析、初始化、使用、卸载七个过程），是不是有点懵。下面我们来做几个小例子。

public class Book {
    public static void main(String[] args)
    {
        System.out.println("Hello ShuYi.");
    }

    Book()
    {
        System.out.println("书的构造方法");
        System.out.println("price=" + price +",amount=" + amount);
    }

    {
        System.out.println("书的普通代码块");
    }

    int price = 110;

    static
    {
        System.out.println("书的静态代码块");
    }

    static int amount = 112;
}

　　思考一下上面这段代码输出什么？

书的静态代码块
Hello ShuYi.

　　和你想的一样吗？

　　我们来简单分析下，首先根据上述5种情况中的第4种（JVM会首先初始化用户指定的带有main主方法的类），既是我们会进行类的初始化。

　　注意看，我们的代码中，有一个构造方法，但是实际上JAVA代码编译成字节码后，是没有构造方法的概念的，只有类初始化方法和对象初始化方法。

　　那么这两个方法什么构成的呢？

类的初始化方法。编译器会按照代码的出现顺序，收集类变量的赋值语句、静态代码块，最终组合成类的构造器。类初始化方法一般在类初始化的时候进行。

　　那么上面的例子中，其类的初始化方法构成就是以下代码了：

 static
    {
        System.out.println("书的静态代码块");
    }
 static int amount = 112;

对象初始化方法。编译器会按照代码的出现顺序，收集类成员变量的赋值语句、普通代码块、最后才收集构造函数里的代码，最终组合成对象构造器。对象初始化方法一般在实例化类对象的时候执行（例如 new 一个对象）。

　　还是上面的代码，其对象初始化方法的构成如下：

    {
        System.out.println("书的普通代码块");
    }
    int price = 110;
    // 最后手机构造函数里的代码
    System.out.println("书的构造方法");
    System.out.println("price=" + price +",amount=" + amount);

　　了解类初始化方法和对象初始化方法之后，我们来看上面那段代码，我们就不能难得出上面的答案。

　　可以看到上面的例子其实没有执行对象初始化方法，因为我们确实没有进行Book类对象的实例化，如果你在main方法中增加 new Book()语句，就会发现对象的初始化方法执行了。

　　下面进行更加复杂的情况分析。

　　复杂例子

class Grandpa
{
    static
    {
        System.out.println("爷爷在静态代码块");
    }
}    
class Father extends Grandpa
{
    static
    {
        System.out.println("爸爸在静态代码块");
    }

    public static int factor = 25;

    public Father()
    {
        System.out.println("我是爸爸~");
    }
}
class Son extends Father
{
    static 
    {
        System.out.println("儿子在静态代码块");
    }

    public Son()
    {
        System.out.println("我是儿子~");
    }
}
public class InitializationDemo
{
    public static void main(String[] args)
    {
        System.out.println("爸爸的岁数:" + Son.factor);    //入口
    }
}

　　仔细想想上面这种情况输出结果是什么？

　　如果你自己动手编写上述代码会发现最终结果是：

爷爷在静态代码块
爸爸在静态代码块
爸爸的岁数:25

　　疑问，为什么没有儿子在静态代码块这个字符串？

　　这是因为对于静态字段，只有直接定义了这个字段的类才会被初始化（执行静态代码块）。因此通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。

　　我们一步一步分析下：

首先程序到main方法，打印输出Son类中factor类变量，但是Son类中并没有定义这个类变量。于是往父类中找，在Father类中找到对应的类变量，于是先触发了Father的初始化。
但根据上面说到初始化的5种情况的第3种（当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化）。我们需要先初始化Father类的父类，也就是初始化Grandpa 在初始化Father类，于是就打印出爷爷在静态代码块，在打印爸爸在静态代码块。
最后，所有父类都初始化完成之后，Son类才能调出父类的静态变量，最后输出爸爸的岁数：25 。

　　应该有点头绪了吧，对于这类题目。

　　再来看一个更加复杂的例子：

class Grandpa
{
    static
    {
        System.out.println("爷爷在静态代码块");
    }

    public Grandpa() {
        System.out.println("我是爷爷~");
    }
}
class Father extends Grandpa
{
    static
    {
        System.out.println("爸爸在静态代码块");
    }

    public Father()
    {
        System.out.println("我是爸爸~");
    }
}
class Son extends Father
{
    static 
    {
        System.out.println("儿子在静态代码块");
    }

    public Son()
    {
        System.out.println("我是儿子~");
    }
}
public class InitializationDemo
{
    public static void main(String[] args)
    {
        new Son();     //入口
    }
}

　　输出结果：

爷爷在静态代码块
爸爸在静态代码块
儿子在静态代码块
我是爷爷~
我是爸爸~
我是儿子~

　　有所不同的是，main方法实例化son对象。

　　我们也来分析下：

首先入口处实例化一个son对象，所以触发son类初始化，而son类初始化，又带动Father、Grandpa类的初始化，从而执行对应类的静态代码块：按顺序输出「爷爷在静态代码块」、「爸爸在静态代码块」、「儿子在静态代码块」。
当son类初始化之后，便会调用son类构造方法，而son类构造方法的调用同样会带动father、grandpa类构造方法的调用，最后输出：我是爷爷、我是爸爸、我是儿子。

　　现在应该都掌握得差不多了，最后来看看特殊一点的例子：

public class Book {
    public static void main(String[] args)
    {
        staticFunction();
    }

    static Book book = new Book();

    static
    {
        System.out.println("书的静态代码块");
    }

    {
        System.out.println("书的普通代码块");
    }

    Book()
    {
        System.out.println("书的构造方法");
        System.out.println("price=" + price +",amount=" + amount);
    }

    public static void staticFunction(){
        System.out.println("书的静态方法");
    }

    int price = 110;
    static int amount = 112;
}

　　输出结果为：

书的普通代码块
书的构造方法
price=110,amount=0
书的静态代码块
书的静态方法

　　这次这个例子，和前面最不同的地方就是main方法中有很多其他代码，所以我们没办法直接忽略main方法所在类的初始化。

当JVM在准备阶段的时候，便会为类变量分配内存和进行初始化（赋予默认值），此时，Book类的类变量book被初始化为零值（默认值）null，amount初始化为默认值0 。
当进入初始化阶段后，因为Book的main方法是程序入口，根据上面类初始化第四种情况，先初始化main方法所在类，所以先初始化Book类。
JVM对Book类进行初始化首先执行类初始化方法（按顺序手机所有静态方法和类变量赋值语句），如果有实例化对象的话，后执行对象初始化方法（按顺序手机变量赋值和普通代码块，最后收集对象构造器）

　　对于上面Book类，其类的初始化方法，可以简单看作以下几个，按顺序执行：

static Book book = new Book();
static
{
    System.out.println("书的静态代码块");
}
static int amount = 112;

　　于是首先执行了 static Book book = new Book(); 这条语句，这条语句又触发了对象初始化方法，就是以下代码，按顺序执行：

{
    System.out.println("书的普通代码块");
}
int price = 110;
Book()
{
    System.out.println("书的构造方法");
    System.out.println("price=" + price +", amount=" + amount);
}

　　于是此时执行顺序：书的普通代码块，price赋值110，书的构造方法，而amount的赋值语句并未执行，所以还是在准备阶段赋值的零值（默认值0），所以之后输出price=110,amount=0。

　　当Book类对象初始化方法完成之后，既 static Book book = new Book(); 这条语句执行完成后，JVM继续进行类初始化方法：

static Book book = new Book();  //完成类实例化
static
{
    System.out.println("书的静态代码块");
}
static int amount = 112;

　　既输出书的静态代码块，之后对amount赋予112的值。

到这里，类的初始化完成，JVM执行main方法的内容。

public static void main(String[] args)
{
    staticFunction();
}

　　既输出：书的静态方法。

　　方法论

　　从上面几个例子可以看出，分析一个类的执行顺序大概可以总结为以下步骤：

准备阶段确定类变量的初始值。在类加载的准备阶段，JVM会为类变量初始化零值（默认值），如果是final修饰的类变量，则直接会被初始化用户代码的值。
初始化入口方法（main方法）。当进入类加载的初始化阶段后，JVM会寻找main主方法入口，从而初始化main方法所在的整个类，当需要对一个类进行初始化时，会首先执行类初始化方法（也可以叫做初始化类构造器），之后执行对象初始化方法（也可以叫做初始化对象构造器）。
类的初始化方法。JVM会按照代码顺序收集类变量的赋值语句、静态代码块、最终组成类构造器由JVM执行。
对象初始化方法。JVM会收集成员变量的赋值语句、普通代码块、最后收集构造方法，将他们组合成对象构造器，最终由JVM执行。

　　如果在初始化main方法所在类的时候遇到其他类的初始化。那么就先加载对应的类，加载完成之后放回，如此反复循环，最终返回main方法所在类。

　　总结

　　看完上面的解析之后，再动手自己写下代码，就能加深影响。大家一起加油。

posted @ 2022-08-30 14:49 梅晓煜阅读(130) 评论(0) 收藏举报

刷新页面返回顶部

meixiaoyu

JVM基础系列：JVM 类加载机制

公告