类加载的时机与过程

￡神魔★判官ぃ 2022-05-24 12:39 199阅读 0赞

虚拟机把描述类的数据从Class文件加载到内存并对数据进行校验，转换解析和初始化最终形成可以被虚拟机直接使用的java类型这就是虚拟机的类加载机制。

类从被加载到虚拟机内存中开始到卸载出内存为止，它的生命周期包括加载（Loading）,验证（Verification），准备（Preparation），解析（Resolution）,初始化（Initialization），使用（Using）和卸载（Unloading）7个阶段其中验证准备和解析统称为连接（Linking）。

![70][]

加载，验证，准备，初始化和卸载的顺序时确定的，类的加载过程必须按这种顺序开始，而解析则在某种情况下可以在初始化阶段之后再开始（动态绑定）。

对于加载java虚拟机中没有强制约束。但是对于初始化虚拟机严格规定了有且只有5种情况必须对类进行初始化（加载验证准备自然要在此之前开始）：

1.遇到new,getstatic,putstatic,invokestatic这4条字节码指令时如果类没有进行初始化则先触发其初始化。生成这4条指令最常见的常见是：使用new实例对象，读取或者设置一个类的静态字段字段（被final修饰、在编译期把结果放入常量池的静态字段除外）的时候，调用一个类的静态方法的时候。

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

3.当初始化一个类的时候发现其父类没有进行过初始化则先触发其父类初始化。

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

5.使用JDK1.7动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后解析结果是REF\_getStatic,REF\_putStatic,REF\_invokeStatic的方法句柄，并且这个方法句柄对应的类没有进行过初始化则需要先触发其初始化。

这五种行为称为对一个类的主动引用。除此之外，所有引用类的方法都不会触发初始化称为被动引用。

实例1.（通过子类引用父类的静态字段，不会导致子类的初始化。）

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!");
        }
    }
    
    public class Initialization{
        public static void main(String[] args) {
                System.out.println(SubClass.value);
        }
    }

![70 1][]

从结果可以看到它只输出了SuperClass init没有输出SubClass init对于静态字段，只有直接定义这个字段的类才会被初始化，因此通过其子类来引用父类定义的静态字段只会触发父类初始化。

实例2.（通过数组义来引用类不会触发此类的初始化）

![70 2][]

从结果看到运行后什么也没输出,说明没有触发(包.SuperClass)的初始化阶段。但是这段代码触发了一个叫(L包.SuperClass)类的初始化阶段，它是一个由虚拟机自动生成的直接继承与Object的子类，创建动作有字节码指令newarray触发。这个类代表了一个元素类型为（包.SuperClass）的一维数组。

实例3.（常量在编译阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。）

public class ConstClass{
        static{
            System.out.println("ConstClass init!");
        }
        public static final String value="Hello";
    }
    
    public class Initialization{
        public static void main(String[] args) {
               System.out.println(ConstClass.value);
        }
    }

![70 3][]

运行后没有输出ConstClass init这是因为ConstClass类的常量在编译阶段通过常量传播优化已经将常量的值存储到Initialization类的常量池中，所以Initialization对ConstClass.value的引用实际都被转换成了Initialization类对自身常量池的引用。也就是说Initialization的class文件中没有对ConstClass类的符号引用入口，这两个类编译成class文件后就不存在任何联系。

接口的加载过程与类加载过程有点不同，其真正产生区别是上面说的5种初始化场景的第三种：当初始化一个类的时候发现其父类没有进行过初始化则先触发其父类初始化。但是接口在初始化时不要求其父接口全部都完成初始化只有在真正使用到父接口的时候（引用接口中定义的常量）才会初始化。

### **类加载过程**    ###

### 1.加载 ###

在加载阶段虚拟机需要完成三件事：

1.通过类的全限定名来获取此类的二进制字节流。（从zip包读取最终发展成JAR,EAR,WAR格式；从网络中获取最典型的应用就是Applet；运行时计算生成使用的最多的就是动态代理技术；由其他文件生成Jsp；数据库读取（相对少见）……）

2.将这个字节流所代表的静态存储结构转换为方法区的运行时数据结构。

3.在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。

对于数组类而言情况有所不同，数组类本身不通过类加载器（loadClass（））创建,它由java虚拟机直接创建。但数组类与类加载器仍有密切的关系，因为数组类的元素类型最终是靠类加载器创建的。一个数组类创建遵循以下规则：

1.如果数组的组件类型是引用类型，那就递归采用本节中定义的加载过程去加载这个组件类型，数组类将在加载该组件类型的类加载器的类名称空间上呗标示（一个类必须与类加载器一起确定唯一性）。

2.如果数组的组件类型不是引用类型（如int\[\]），java虚拟机将会把数组类标记为与引导类加载器关联。

3.数组类的可见性与他的组件类型的可见性一致，如果组件类型不是引用类型，那数组类的可见性将默认为public。

加载阶段完成后，虚拟机外部的二进制字节流按虚拟机所需的格式存储在方法区（虚拟机规范未规定此区域具体的数据结构）。然后在内存中实例化一个java.lang.Class类的对象（没有明确规定在堆中，对HotSpot虚拟机来讲，Class对象虽然是对象但是存放在方法区），这个对象将作为程序访问方法区中的这些类型数据的外部接口。

加载阶段与连接阶段的部分内容（如一部分字节码文件格式的验证动作）是交叉进行的，加载阶段尚未完成，连接阶段可能已经开始了，但是在与加载阶段中进行的动作，仍然属于连接阶段的内容，这两个阶段的开始时间仍然保持固定的先后顺序。

### 2.验证    ###

验证是连接阶段的第一步，这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求且不会危害虚拟机自身的安全。从整体上看验证阶段大致会完成4个阶段的校验：文件格式验证、元数据验证、字节码验证、符号引用验证。

**1.文件格式验证**

第一阶段要验证字节流是否符合Class文件格式的规范，并且能被当前版本的虚拟机处理，这一阶段可能包括下面这些验证点：

1.1：是否以魔数0xCAFEBABE开头。

1.2：主次版本是否在当前虚拟机处理范围之内。

1.3：常量池的常量中是否有不被支持的常量类型（检查常量tag标志）。

1.4：指向常量的各种索引值中是否有指向不存在的常量或不符合类型的常量。

1.5：CONSTANT\_Utf8\_info型的常量中是否有不符合UTF8编码的数据。

1.6：Class文件中各个部分及文件本身是否有被删除的或附加的其他信息。

…………………………等等

该验证阶段主要目的是保证输入的字节流能正确地解析并存储于方法区之内，格式上符合描述一个Java类型信息的要求。这阶段的验证是基于二进制字节流进行的，只有通过了这个阶段的验证后字节流才会进入内存的方法区中进行存储，所以后面的三个验证阶段全部是基于方法区的存储结构进行的，不会再直接操作字节流。

**2.元数据验证**

第二阶段是对字节码描述的信息进行语义分析，以保证其描述的信息符合Java语言规范的要求，这个阶段可能包括的验证点如下：

2.1：这个类是否有父类（除了java.lang.Object之外，所有的类都应当有父类）。  
2.2：这个类的父类是否继承了不允许被继承的类（final修饰的类）。  
2.3：如果这个类不是抽象类，是否实现了其父类或接口中要求实现的方法。  
2.4：类中的字段方法是否与父类产生矛盾（如：覆盖了父类的final字段，出现了不符合规则的方法重载，例如方法参数都一致，但返回值类型却不同等）。  
……………………等等

第二阶段的主要目的是对类的元数据信息进行语义校验，保证不存在不符合Java语言规范的元数据信息。

**3.字节码验证**

第三阶段是整个验证过程中最复杂的一个阶段，主要目的是通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。在第二阶段对元数据类型做完校验后，这个阶段将对类的方法体进行校验分析，保证被校验类的方法在运行时不会做出危害虚拟机安全的事件，例如：

3.1：保证跳转指令不会跳转到方法体以外的字节码指令上。

3.2：保证任意时刻操作数栈的数据类型与指令代码序列都能配合工作，例如不会出现在操作栈放置一个int类型的数据，使用时却按long类型来加载入本地变量表中。

3.3：保证方法体中的类型转换时有效的，例如把子类对象赋值给父类数据类型是安全的，但是把父类对象赋值给子类是不合法的。

…………等等

如果一个类方法体的字节码没有通过字节码验证，那肯定是有问题；但是如果一个方法体通过了字节码验证也不能说明其一定是安全的。

由于数据流验证的高复杂性，为了避免过多时间消耗在字节码验证阶段，JDK1.6以后javac编译器和java虚拟机给方法体的Code属性的属性表增加了一项‘StackMapTable’属性，这项属性描述了方法体中所有基本块（Basic Block,按照控制流拆分的代码块）开始时本地变量表和操作栈应有的状态，在字节码验证期间，就不需要根据程序推导这些状态的合法性，只需要检查StackMapTable属性中的记录是否合法即可。这样将字节码验证的类型推导成类型检查从而节省一些时间。（理论上StackMapTable属性有被篡改的可能性）

**4.符号引用验证**

最后一个阶段的校验发生在虚拟机将符号引用转换为直接引用的时候，这个转化动作将在连接的第三阶段-解析阶段中发生。符号引用验证可以看做是对类自身以外（常量池中的各种符号引用）的信息进行匹配性校验，通常需要校验下列内容：  
4.1：符号引用中通过字符串描述的全限定名是否能找到对应的类。  
4.2：在指定类中是否存在符合方法的字段描述符以及简单名称所描述的方法和字段。  
4.3：符号引用中的类、字段、方法的访问性（private,protected,public,default）是否可以被当前类访问。  
……………………等等  
符号引用验证的目的是确保解析动作能正常执行，如果无法通过符号引用验证，会抛出java.lang.IncompatibleClassChangError异常的子类如java.lang.IllegalAccessError、java.lang.NoSuchFieldError、java.lang.NoSuchMethodError等。

对于虚拟机的类加载机制来说验证很重要但是非必要。如果所运行的代码都已经反复验证过，那么在实施阶段可以考虑使用-Xverify:none参数来关闭大部分类验证措施。从而缩短虚拟机类加载的时间。

### 3.准备 ###

准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都在方法区中进行分配。这个阶段有两个概念容易混淆：这时候进行内存分配的仅包括类变量（static修饰的变量），不包括实例变量，实例变量会在对象实例化时随着对象一起分配在java堆中。这里说的初始值“通常情况”下是数据类型的零值，如（public static int value =123;）变量在准备阶段后的初始值为0不是123。而把value赋值为123的putstatic指令是在程序编译后，存放在类构造器<clinit>()方法中，所以给value赋值123动作是在初始化阶段才会进行。

![70 4][]

上面说的是“通常情况”下初始值是零值，相对的“特殊情况”就是当类字段的字段属性表存在ConstantValue属性，那在准备阶段变量value就会被初始化为ConstantValue属性所指定的值，如：public static final int value=123;  
编译时javac会为valu生成ConstantValue属性，在准备阶段虚拟机就会根据ConstantValue将value赋值为123。

### 4.解析 ###

解析阶段是虚拟机将常量池内符号引用替换为直接引用的过程，在class文件中它以CONSTANT\_Class\_info、CONSTANT\_Fieldref\_info、CONSTANT\_Methodref\_info等类型的常量出现。解析阶段说的直接引用和符号引用的关联：  
符号引用：符号引用以一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义的定位到目标即可。（符号引用与虚拟机实现的内存布局无关，引用的目标不一定已经加载到内存中。）  
直接引用：直接引用可以是直接指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄。（直接引用和虚拟机实现的内存布局相关，同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同。如果有了直接引用，那引用的目标必定已经在内存中存在）

虚拟机规范中并未规定解析阶段发生的具体时间，只要求在执行anewarray、checkcast、getfield、getstatic、instanceof、invokedynamic、invokeinterface、invokespecial、invokestatic、invokevirtual、ldc、ldc\_w、multianewarray、new、pufield、putstatic这16个用于操作符号引用的字节码指令之前，先对它们所使用的符号引用进行解析。

解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用进行。分别对应常量池的CONSTANT\_Class\_info、CONSTANT\_Fieldref\_info、CONSTANT\_Methodref\_info、CONSTANT\_InterfaceMethodref\_info、CONSTANT\_MethodType\_info、CONSTANT\_MethodHandle\_info、CONSTANT\_InvokeDyname\_info7种常量类型。

### 5.初始化 ###

类初始化阶段是类加载的过程的最后一步，前面的类加载过程中，除了在加载阶段用户应用程序可以通过自定义类加载器参与外，其余动作完全由虚拟机主导控制。初始化阶段才真正开始执行类中定义的java代码（字节码）。

在准备阶段变量已经赋值过一次系统要求的初始值。而初始化阶段则根据我们通过程序制定的主管计划去初始化类变量和其他资源。（初始化阶段是执行类构造器<clinit>（）方法的过程）

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

public class Test{
    	
    	static {
    		i=0;//正常编译通过
    		System.out.println(i);//会报错"非法向前引用"
    		
    	}
    	static int i=0;
    }

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

由于父类方法的<clinit>()方法先执行，所以父类中定义的静态语句块优先于子类的变量赋值。所以下面代码输出会是2而不是一。

public class Test{
    	
    	static int i=1;
    	static {
    		i=2
    	}
    }
    
    public class Tests extends Test{
    	
    	public static int B=i;
    }
    
    public static void main(String[] args) {
    	System.out.println(Tests.B);
    	
    }

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

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

虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步，如果多个线程同时初始化一个类，那么只会有一个线程去执行这个类的<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕。

public class DeadLoopClass {
    	static {
    		if(true)//不加if会拒绝编译
    		{
    			System.out.println(Thread.currentThread()+"init");
    			while(true)
    			{
    				
    			}
    		}
    	}
    }
    
    
    public class Init {
    	
    	public static void main(String[] args) {
    		Runnable script = new Runnable() {
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				System.out.println(Thread.currentThread()+"start");
    				DeadLoopClass dlc =new DeadLoopClass();
    				System.out.println(Thread.currentThread()+"run over");
    			}
    		};
    		
    		Thread thread1=new Thread(script);
    		Thread thread2=new Thread(script);
    		thread1.start();
    		thread2.start();
    		
    	}
    }

运行结果：一条线程在死循环以模拟长时间操作，另一条线程阻塞等待。

![70 5][]

(emmmmmm如果发现哪里有错了的地方或者不对的地方请在评论处留言，我看到后会改……)

[70]: /images/20220524/7d70ec6443764c32b8d474fe10ce7459.png
[70 1]: /images/20220524/d48b88123d5e4513a1cbf32feb71ae2d.png
[70 2]: /images/20220524/0fb2322768b44e53b2f006f49a07a498.png
[70 3]: /images/20220524/b44f07dfa8c94c3fb8e6f65b98a95da7.png
[70 4]: /images/20220524/9b2030d46ac94ac293f1e7370e907fe0.png
[70 5]: /images/20220524/1eed595311fc4d2895534af40b2509e9.png