JVM学习笔记之类加载机制【八】

1604733785261-8dcada65-db68-41fb-9ef1-9dabd6396bac

一、类加载时机

1.1 触发类初始化的六个场景: 加载？

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

如果类型没有进行过初始化，则需要先触发其初始化阶段。生成这四条指令的Java代码场景是：

  • 使用new关键字实例化对象的时候
  • 读取或设置一个类型的静态字段（被final修饰、已在编译期把结果放入常量池的静态字段除外）的时候
  • 调用一个类型的静态方法的时候

2、 使用java.lang.reflect包的方法对类型进行反射调用的时候，如果类型没有进行过初始化，则需要先触发其初始化。

3、当初始化类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。

4、当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。

5、　当使用JDK 7新加入的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果为REF_getStatic、REF_putStatic、REF_invokeStatic、REF_newInvokeSpecial四种类型的方法句柄，并且这个方法句柄对应的类没有进行过初始化，则需要先触发其初始化。

6、当一个接口中定义了JDK 8新加入的默认方法（被default关键字修饰的接口方法）时，如果有这个接口的实现类发生了初始化，那该接口要在其之前被初始化。

注意：以上情况称为称对一个类进行“主动引用”，除此种情况之外，均不会触发类的初始化，称为“被动引用”

1.2 被动引用的例子

public class SuperClass {
    static {
        System.out.println("SuperClass init!");
    }
    public static int value = 123;
}

public class SubClass extends SuperClass{
    static {
        System.out.println("SubClass init!");
    }
}

  • 通过子类引用父类的静态字段，不会导致子类的初始化

    /**
 * 被动引用： 演示一
 * 非主动使用类字段演示
 * jvm args: -XX:+TraceClassLoading  打印类加载轨迹
 * @author hdj
 */
public class NoInitializationWithStaticField {
    public static void main(String[] args) {
        System.out.println(SubClass.value);
    }
}
//输出
SuperClass init!
123

    所以，对于静态字段，只有直接定义这个字段的类才会被初始化，因此通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。

  • 通过数组定义来引用类，不会触发此类的初始化

    public class NoInitializationWithArrayRef {
    public static void main(String[] args) {
        SuperClass[] sca = new SuperClass[10];
    }
}

//输出， 可以发现没有输出SuperClass init!

    注意： 这段代码里面触发了另一个名为“[Lcn.hdj.jvm.classloading.SuperClass”的类的初始化阶段，它是一个由虚拟机自动生成的、直接继承于java.lang.Object的子类，创建动作由字节码指令newarray触发。这个类代表了一个元素类型为cn.hdj.jvm.classloading.SuperClass的一维数组

  • 常量在编译阶段存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此不会触发定义的常量

    public class ConstClass {
    static {
        System.out.println("ConstClass init!");
    }
    public static String HELLOWROLD="helloworld";
}

/**
 * 被动引用： 演示三
 * 常量在编译阶段存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此不会触发定义的常量
 *
 * @author hdj
 */
public class NoInitializationWithConst {
    public static void main(String[] args) {
        System.out.println(ConstClass.HELLOWROLD);
    }
}
//输出
helloworld

    注意：这里之所以没有输出"ConstClass init!"， 是因为在编译阶段通过常量传播优化，已经将此常量的值“hello world”直接存储在NoInitializationWithConst类的常量池中，以后NoInitializationWithConst对常量ConstClass.HELLOWORLD的引用，实际都被转化为NoInitializationWithConst类对自身常量池的引用了。

1.3 接口加载过程

接口也有初始化过程，这点也类是一致的。接口中不能使用static{} 静态代码块，但编译器仍然会为接口生成<clinit>()构造器，用于初始化接口中所定义的成员变量。接口初始化与类不同的是: 当一个类初始化时，要求其父类全部初始化完成，但一个接口初始化时，并不要求其父接口全部初始化完成，只有真正使用到父接口时才会初始化。

二、类加载过程

2.1 加载(Loading): 找Class文件

2.1.1 Java虚拟机在加载阶段要完成三件事：
  • 通过一个类的全限定名来获取定义该类的二进制子节流
  • 将子节流所代表的静态存储结构转化为方法区的运行时数据结构
  • 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。
2.1.2 数组加载的遵循规则
  • 如果数组的组件类型(Component Type)是引用类型，则递归通过类加载器加载（一个类必须与类加载器确定唯一性）
  • 如果数组的组件类型不是引用类型，虚拟机会将数组标记为与引导类加载器关联
  • 数组的可见性与它的组件类型可见性一致，如果组件类型不是引用类型，那数组的的可见性将默认为public

2.2 验证(Verification)：验证格式、依赖

验证是连接阶段的第一步，这个阶段的目的是为了确保Class文件的子节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机的自身安全。分为以下四个阶段的校验。

  • 文件格式验证

  • 元数据校验

  • 字节码校验

  • 符号引用校验

对应虚拟机来说，验证阶段是一个非常重要的，但不是一定必要（对于程序运行期没有影响）的阶段。所以可以部署时通过虚拟机参数

-Xverify:none来关闭验证，缩短虚拟机加载时间。

2.3 准备(Preparation)：静态字段、方法表

​ 准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。

注意：　这个阶段进行分配的变量仅仅是类变量(被static修饰的变量)，而实例变量将会在对象实例化时随着对象一起分配在Java堆中。还有这个阶段的初始化，"通常情况"下是数据类型的零值。

public static int value = 123;

上述变量value 在准备阶段过后的初始化值为0而不是123，因为这时候尚未开始执行任何Java方法，而把value 赋值123的putstatic 指令是在程序被编译后，存放在类构造器<clinit>()方法之中，所以把value 赋值123的动作在初始化阶段才会执行。

  • 基本数据类型的零值
数据类型 零值 数据类型 零值
int 0 boolean false
long 0L float 0.0f
short (short)0 double 0.0d
char '\u0000' reference（引用类型） null
byte (byte)0
  • 特殊情况下会初始化指定值

如果类字段的字段属性存在ConstantValue属性，则会在准备阶段变量value会初始化为ConstantValue属性所指定的值。如以下定义的字段

public static final int value = 123;

2.4 解析(Resolution)：符号解析引用

​ 解析阶段是虚拟机将常量内的符号引用替换为直接引用的过程。

  • 符号引用（Symbolic References）

    • 符号引用以一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可。
    • 符号引用与虚拟机实现的布局无关，引用的目标不一定已经加载到内存中。
    • 各种虚拟机实现的内存布局可以各不相同，但是它们能接受的符号引用必须都是一致的，应为符号引用的字面量形式明确定义在Java虚拟机规范的Class文件格式中。

  • 直接引用(Direct References)

    • 直接引用可以是直接指向目标的指针、相对偏移量或者是一个能间接定位到目标的句柄。
    • 直接引用是和虚拟机实现的内存布局相关的，同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同。
    • 如果又有了直接引用，那引用的目标必定在内存中存在。

  • 解析阶段的具体时间

    虚拟机规范中并没有规定解析阶段发生的具体时间，只要求在执行以下16个用于操作符号引用的字节码指令前，先对它们所使用的符号引用进行解析。

    anewarray
checkcast
getfeild
getstatic
instanceof
invokedynamic
invokedinterface
invokedspecial
invokestatic
invokevirtual
ldc
ldc_w
multianewarray
new
putfield
putstatic

  • 类或接口的解析

    假设在当前代码所在的类为D，如果要把一个从未解析过的符号引用N解析为一个类或者接口C的直接引用，虚拟机完成解析过程需要以下3个步骤：

    • 1、如果C不是一个数组类型，那虚拟机将会把代表N的全限定名传递个D的类加载器去加载这个类C。在加载过程中，由于元数据验证、字节码验证的需要，又可能触发其他相关类的加载动作，例如加载这个类的父类或实现的接口。一旦这个加载过程出现任何异常，解析过程就宣告失败。
    • 2、如果C是一个数组类型，并且数组元素类型为对象，也就是N的描述符会是类似 "[Ljava/lang/Integer" 的形式，那将会按照第一点的规则加载数组元素类型。如果N的描述符如前面所假设的形式，需要加载的元素类型就是 "java.lang.Integer"，接着有虚拟机生成一个代表此数组维度和元素的数组对象。
    • 3、如果上面步骤正常执行，那么C在虚拟机中实际上已经成为一个有效的类或者接口了，但解析完成之前还要进行符号引用验证，确认D是否具备对C的访问权限。如果发现不具备访问权限，将会抛出java.lang.IllegalAccessError异常

  • 字段解析

    如果在解析这个类或接口符号引用的过程中出现了任何异常，都会导致字段符号引用解析的失败。假设这个字段所属的类或接口用C表示，字段解析分为以下步骤

    • 1、如果Ｃ本身就包含简单名称和字段描述都与目标相匹配的字段，则返回这个字段的直接引用，查找结束。
    • 2、否则，如果在C中实现接口，将会按照继承关系从下往上递归搜索各个接口和它父接口，如果接口中包含简单名称和字段描述都与目标相匹配的字段，则返回这个字段的直接引用，查找结束。
    • 否则，如果C不是java.lang.Object的话，将会按照继承关系从下往上递归搜索其父类，如果父类中包含简单名称和字段描述都与目标相匹配的字段，则返回这个字段的直接引用，查找结束。
    • 否则，查找失败，抛出java.lang.NoSouchFieldError异常
    • 正常返回引用后，将会对这个字段进行权限验证，如果发现不具备该字段的访问权限，将会抛出java.lang.IllegalAccessError异常
    package cn.hdj.jvm.classloading;

/**
 * @Description: 字段解析，　字段引用不明确导致解析失败
 * @Author huangjiajian
 * @Date 2021/4/10 下午11:01
 */
public class FieldResolution {

    interface Interface0 {
        int A = 0;
    }

    interface Interface1 extends Interface0 {
        int A = 1;
    }


    interface Interface2 {
        int A = 0;
    }

    static class Parent implements Interface1 {
        public static int A = 3;
    }

    static class Sub extends Parent implements Interface2 {
        //注释字段A
        //这时因为父类Parent　和接口　Interface2都包含字段A，导致解析字段引用不明确，解析失败
        //public static int A = 4;
    }

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

  • 类方法解析

    类方法解析与字段解析步骤一样，也是需要先解析类方法表的class_index中索引的方法所属的类或接口符号引用，解析成功才进行类方法解析，假设这个类方法所属的类或接口用C表示，解析分为以下步骤:

    • 1、类方法和接口方法符号引用的常量类型定义是分开的，如果在类方法表中发现class_index中索引的C是个接口，那就直接抛出java.lang.IncompoatibleClassChangeError异常.
    • 2、如果Ｃ中查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束。
    • 3、否则，如果在C的父类中递归查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束。
    • 4、否则，在类C实现的接口列表或父接口中递归查找是否有简单名称和描述符都与目标想匹配的方法，如果存在匹配的方法，说明类C是一个抽象类，这时查找结束，抛出java.lang.AbstactMethodError异常。
    • 5、否则，查找失败，抛出java.lang.NoSouchFieldError异常
    • 6、正常返回引用后，将会对这个方法进行权限验证，如果发现不具备该方法的访问权限，将会抛出java.lang.IllegalAccessError异常

  • 接口方法解析

    假设这个类方法所属的类或接口用C表示，解析分为以下步骤:

    • 1、与类方法解析不同，如果在接口方法表中发现class_index索引C是个类而不是接口，那就抛出java.lang.IncompoatibleClassChangeError异常.
    • 2、否则，在接口C中查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束。
    • 3、否则，在接口C的父接口中递归查找，直到java.lang.Object类为止，看是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束。
    • 4、否则，查找失败，抛出java.lang.NoSouchFieldError异常
    • 5、由于接口中的所有方法都是public的，所以不存在访问权限问题。

2.5 初始化(Initalization)：构造器、静态变量赋值、静态代码块

​ 类初始化是类加载过程的最后一步，前面的类加载过程中，除了在加载阶段用户应用程序可以通过自定义类加载器参与外，其余动作完全有虚拟机主导和控制。

​ 初始化阶段是执行类构造器<clinit>()方法的过程。

  • <clinit>()方法是有编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}）中语句合并产生的，编译器收集的顺序是有语句在源文件中出现的顺序所决定的，静态语句块中只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块可以赋值，但是不能访问

    public class InitOrder {
    static {
        i = 0; //可以赋值
        //System.out.println(i); //编译器，提示　Illegal forward reference　(非法向前引用)
    }

    //定义在静态代码块后的静态变量
    static int i = 1;
    
}

  • <clinit>() 方法与类的构造器函数(<init>())不同，他不需要显式地调用父类构造器，虚拟机会保证在子类的<clinit>()方法执行之前，父类的<clinit>()方法执行已经完毕。因此在虚拟机中第一个被执行的<clinit>()方法的类肯定是java.lang.Object。

  • 由于父类的<clinit>()方法先执行，也意味着父类中定义的静态语句块要优先与子类的变量赋值操作

    1574242929008-8963e80a-f4eb-4c04-b57a-4b30c6b71af8

  • <clinit>()对于类或接口来说不是必需的，如果一个类中没有静态语句块，也没有对静态变量的赋值操作，那么编译器可以不为这个类生成<clinit>()方法。

  • 接口中不能使用静态语句块，但仍然有静态变量初始化的赋值操作，因此接口与类一样都会生成<clinit>()方法。但接口与类不同的是，执行接口的<clinit>()方法不需要先执行父接口的<clinit>()方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的<clinit>()方法。

  • 虚拟机会保证一个类<clinit>()方法在多线程环境中被正确地加锁、同步。如果<clinit>()方法执行很耗时，那么会造成多个线程阻塞。

    public class DeadLoopClassTest {

    static class DeadLoopClass{
        static {
            if (true) {
                System.out.println(Thread.currentThread() + "init DeadLoopClass");
                while (true) {
                }
            }
        }
    }
    
    public static void main(String[] args) {
        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread() + "start");
                DeadLoopClass deadLoopClass=new DeadLoopClass();
                System.out.println(Thread.currentThread() + "run Over");
            }
        };

        Thread thread1=new Thread(runnable);
        Thread thread2=new Thread(runnable);

        thread1.start();
        thread2.start();
    }
}

//输出
Thread[Thread-0,5,main]start
Thread[Thread-1,5,main]start
Thread[Thread-1,5,main]init DeadLoopClass

  • 注意：<clinit>() 在同一类加载器下，一个类型只会初始化一次。

三、类加载器

3.1 类与类加载器

  • 加载类的类加载器不同，则两个类一定相等

  • "相等"，包括代表类的Class 对象的equals()方法、isAssignableFrom()方法、isIntance()方法、instanceof 关键字判定

  • 以下使用两个不同类加载器加载相同的类，使用instanceof判定是否为同一个类

    public class ClassLoaderTest2 {

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        ClassLoader classLoader = new ClassLoader() {
            @Override
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                try {
                    String fileName = name.substring(name.lastIndexOf('.') + 1) + ".class";
                    InputStream inputStream = this.getClass().getResourceAsStream(fileName);
                    if (inputStream == null) {
                        return super.loadClass(name);
                    }
                    byte[] buffer = new byte[inputStream.available()];
                    inputStream.read(buffer, 0, buffer.length);
                    return this.defineClass(name, buffer, 0, buffer.length);
                } catch (Exception e) {
                    throw new ClassNotFoundException(name);
                }
            }
        };

        Object o = classLoader.loadClass("cn.hdj.jvm.classloading.ClassLoaderTest2").newInstance();
        System.out.println(o.getClass());
        System.out.println(o instanceof cn.hdj.jvm.classloading.ClassLoaderTest2);
    }
}

//输出
class cn.hdj.jvm.classloading.ClassLoaderTest2
false

3.2 双亲委派模型

image-20210411184503777

  • 启动类加载器(Bootstrap ClassLoader)：　这个类加载器负责加载以下路径的类库加载到虚拟机内存中

    • <JAVA_HOME>\lib路径
    • -Xbootclasspath 指定的路径
    • 指定路径下的类库，还要能被虚拟能识别的类库，如仅按照文件命名识别类库 rt.jar
    • 注意，启动类加载器无法被Java程序直接引用

  • 扩展类加载器( Extension ClassLoader)：这个加载器由sun.misc.Launcher$ExtClassLoader实现，负责加载以下规则定义的类库

    • <JAVA_HOME>\lib\ext路径下的类库
    • java.ext.dirs系统变量所指定的路径下的类库
    • 开发者可以直接使用扩展类加载器

  • 应用程序类加载器(Application ClassLoader，也称为系统类加载器)：这个类加载器由sun.misc.Launcher$AppClassLoader实现。负责加载用户类路径( ClassPath )上指定的类库

    • 一般情况下，是程序中默认的类加载器
    • 开发者可以直接使用扩展类加载器

  • 双亲委派模型工作过程：

    • 当前类加载器收到类加载的请求，不会自己去尝试加载这个类，先请求委派父类加载器去完成。
    • 因此所有加载请求最终都应该传送到顶层的启动类加载器中
    • 只有当类加载器反馈自己无法完成这个加载请求，子加载器才会尝试自己加载
posted @ 2021-04-11 20:23  JiaJianHuang  阅读(107)  评论(0)  编辑  收藏  举报