2.JVM的类加载器

一.类加载器深入解析与阶段分解

1.在Java代码中，类型（类）的加载、连接与初始化过程都是在程序运行期间完成的。

 2.Java虚拟机结束生命周期的情况：

• 程序执行了System.exit()方法

• 程序正常执行结束

• 程序执行中遇到异常或错误而异常终止

• 操作系统出现错误导致Java虚拟机终止

3.类的加载、连接与初始化

• 加载：查找并加载类的二进制数据

• 链接

  • 验证：确保被加载的类的正确性

  • 准备：为类的静态变量分配内存，并将其初始化为默认值

    •  默认初始值如下：

      • 八种基本数据类型默认的初始值是0 

      • 引用类型默认的初始值是null 

      • 有static final修饰的会直接赋值，例如：static final int x=10；则默认就是10.

  • 解析：把类中的符号引用转换为直接引用（jvm会将所有的类或接口名、字段名、方法名转换为具体的内存地址。）

• 初始化：为类的静态变量赋予正确的初始值，初始化静态代码块和静态方法

  • 初始化这个阶段就是将静态变量（类变量）赋值的过程，即只有static修饰的才能被初始化，执行的顺序就是：父类静态域或着静态代码块，然后是子类静态域或者子类静态代码块（静态代码块先被加载，然后再是静态属性）

  • 初始化静态代码块和静态方法

• 使用：如创建类的对象，调用类的方法

• 卸载：将驻留在内存里的类的数据结构销毁掉，卸载后不能再使用该类创建对象了

 

注：准备阶段即使我们为静态变量赋值为任意的数值，但是该静态变量还是会被初始化为它的默认值，最后的初始化时才会把我们赋予的值设为该静态变量的值。

 

 

补充：

• 类初始化的过程：

  • 虚拟机在首次加载Java类时，会对静态成员变量、静态代码块、静态方法进行一次初始化

  • 类实例创建过程：

    • 准备阶段：父类静态变量-->子类静态变量

    • 初始化阶段：父类静态变量-->父类静态代码块和静态方法-->子类静态变量-->子类静态代码块和静态方法

    • 使用阶段：父类成员变量-->父类代码块-->父类构造方法-->子类成员变量-->子类代码块-->子类构造方法

    • 总结：父类的（静态变量、静态初始化块、静态方法） => 子类的（静态变量、静态初始化块、静态方法）=> 父类的（变量、初始化块、构造器）=> 子类的（变量、初始化块、构造器）

二.类的加载连接与初始化过程详解

1.Java程序对类的使用方式分为两种

• 主动使用（七种）

  • 创建类的实例

  • 访问某个类或接口的静态变量，或者对该静态变量赋值（对静态变量取值或赋值）

  • 调用该类的静态方法

  • 反射

  • 初始化一个类的子类

  • Java虚拟机启动时被标为启动类的类（包含main方法的类）

  • JDK1.7开始提供的动态语言支持： java.lang.invoke.MethodHandle 实例的解析结果 REF_getStatic,REF_putStatic,REF_invokeStatic 句柄对应的类没有初始化，则初始化

• 被动使用

  • 处理上述七种情况，其他使用Java类的方式都被看作对类的被动使用，都不会导致类的初始化（可能会加载和连接但不会初始化）

2.Java程序中的每一个类或接口再被“首次主动使用”时，Java虚拟机才初始化它们

3.类的加载

• 类的加载:

  • 将类的 .class 文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在内存中创建一个 Java.lang.Class 对象（规范并没有说明Class对象位于哪里，HotSpot虚拟机将其放在了方法区中）用来封装类在方法区的数据结构

• 加载类的方式

  • 从本地系统中直接加载

  • 通过网络下载.class文件

  • 从zip，jar等归档文件中加载.class文件

  • 从专有数据库中提取.class文件

  • 将java源文件动态编译为.class文件（将JAVA源文件动态编译这种情况会在动态代理和web开发中jsp转换成Servlet）

4.案例

（4.1）案例一：子类类名.父类静态变量

（4.2）案例二：子类类名.子类静态变量

• 将 Child.str1改为Child.str2 

（4.3）JVM参数

• 三种配置参数情况：

  •  -XX:+<option> ：开启option选项

  •  -XX:-<option> ：关闭option选项

  •  -XX:<option>=<value> ：将option选项的值设置为value

（4.4）查看程序中类加载情况： -XX:+TraceClassLoading 

结论：加载了Test，Parent和Child这三个类以及大量的Java自定义的类

5.常量的本质含义和反编译以及助记符

（5.1）结论：常量在编译阶段会存入到调用这个常量的方法所在的类的常量池中，本质上是调用类并没有直接引用到定义常量的类，因此并不会触发定义常量类的初始化。

只会输出 hello world 是因为常量str的值已经保存进了MyTest2中，不需要创建MyParent2去访问常量str，则也不会输出静态代码块的内容了。MyParent2类不会被初始化。

/*
* 常量会存放到MyTest2的常量池中，之后MyTest2与MyParent2就没有任何关系了。
* 甚至在我们编译后直接删除掉MyParent2的class文件都可以。
*/
public class MyTest2 {

    public static void main(String[] args) {
        System.out.println(MyParent2.str);
    }
}

class MyParent2 {

    public static final String str = "hello world";

    public static final short s = 127;

    public static final int i = 128;

    public static final int m = 1;

    static {
        System.out.println("MyParent2 static block");
    }
}

 

（5.2）反编译

• 查看自己的.class文件在项目中存放位置并在终端进入

• 使用javap -c 命令查看反编译结果： javap -c edu.ustc.wzh.MyTest2 

（5.3）助记符（部分）

• ldc：表示将int，float，String类型的常量值从常量池中推送到栈顶

• bipush：表示将单字节（-128~127）的常量值推送到栈顶

• sipush：表示将一个短整型常量值（-32768~-32767）推送到栈顶

• iconst_1：由于-1~5比较特殊，jvm将其定义为iconst_m1~iconst_5，表示将int类型1推送到栈顶

6.编译期常量和运行期常量的区别及数组创建本质分析

（6.1）运行期常量

结论：运行期常量：当一个常量值不能在编译期间确定，那么其值就不会被放到调用类的常量池中，这时程序运行时会导致该常量所在的类被初始化

MyParent3类会被初始化！

import java.util.UUID;

public class MyTest3 {

    public static void main(String[] args) {
        System.out.println(MyParent3.str);
    }
}

class MyParent3 {
    public static final String str = UUID.randomUUID().toString();

    static {
        System.out.println("MyParent3 static block");
    }
}

（6.2）数组创建本质分析

（1）创建普通对象：会初始化MyParent4类

public class MyTest4 {

    public static void main(String[] args) {
        MyParent4 myParent4 = new MyParent4();
    }
}

class MyParent4{
    static {
        System.out.println("MyParent4 static block");
    }
}

/*
* 输出：
* MyParent4 static block
* */

（2）创建对象数组：

结论：不会初始化MyParent4

• 对于数组实例，其类型是JVM在运行期动态生成的，动态生成的类型其父类型就是Object

• 对于数组来说，JavaDoc经常将构成数组的元素为Component，实际上就是将数组降低一个维度后的类型

补充助记符：

• anewarray：表示创建一个引用类型（如类、接口、数组）的数组，并将其引用值压入栈顶

• newarray：表示创建一个指定的原始类型（如int、float、char等）的数组

public class MyTest4 {

    public static void main(String[] args) {
        MyParent4[] myParent4 = new MyParent4[1];
        MyParent4[][] myParent4s = new MyParent4[1][];

        System.out.println(myParent4.getClass());
        System.out.println(myParent4.getClass().getSuperclass());
        System.out.println(myParent4s.getClass());
        System.out.println(myParent4s.getClass().getSuperclass());

        System.out.println("=================");
        int[] ints = new int[1];
        System.out.println(ints.getClass());
        System.out.println(ints.getClass().getSuperclass());

    }
}

class MyParent4{
    static {
        System.out.println("MyParent4 static block");
    }
}

/*
* 输出：
class [Ledu.ustc.wzh.MyParent4;
class java.lang.Object
class [[Ledu.ustc.wzh.MyParent4;
class java.lang.Object
=================
class [I
class java.lang.Object
* */

补充：

• 二维数组第二维不赋值和一维数组一样都是用助记符anewarray但是紧随其后的class的名称不同

• 二维数组两个维度都赋值后使用助记符multianewarray，紧随其后的class名称前面有两个[

public class MyTest4 {

    public static void main(String[] args) {

        MyParent4[] myParent4s1 = new MyParent4[1];
        MyParent4[][] myParent4s2 = new MyParent4[1][];
        MyParent4[][] myParent4s3 = new MyParent4[1][10];
    }
}

class MyParent4{
    static {
        System.out.println("MyParent4 static block");
    }
}