【JVM实战】类的加载机制

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

一个类从被加载到虚拟机内存开始，到卸载出内存为止，它的主要生命周期有：加载、连接、初始化。而连接过程又被分为验证、准备、解析这几个过程。所以整个生命周期过程如下：加载、验证。准备、解析、初始化、使用和卸载这7个 过程。下面我们讨论它的主要过程。

类加载的条件

什么时候开始类的加载过程呢？java虚拟机规定，在一个类或者接口的使用之前，必须要进行初始化，这里的使用必须是主动使用，有以下几种情况是主动使用：

1. 当创建一个类的实例时，比如使用new关键字或者通过反射，克隆，反序列化。
2. 当调用类的静态方法时，即当使用了字节码invokestatic指令。
3. 当使用类或接口的静态字段时（final常量除外），比如使用了getstatic或者putstatic指令。
4. 当使用java.lang.reflect包中的方法反射类的方法时。
5. 当初始化子类时，要求先初始化父类。（不包括接口）
6. 作为启动虚拟机，含有main()方法的那个类。

主动使用的例子很多，这里就不赘述了，我们可以看一个被动使用的例子，帮助我们区分主动使用：

class Parent{
	static {
		System.out.println("parent init");
	}
	public static int v=100;
}

class Child extends Parent{
	static {
		System.out.println("child init");
	}
}

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

上面输出的结果是：

parent init
100

可以看到，我们直接访问了子类的对象，但是子类并没有被初始化，只有父类被初始化了，所以，引用一个字段时，只有直接定义该字段的类，才会被初始化。（不过此时子类已经被加载，只是还没有被初始化）。

我们可以使用-XX:+TraceClassLoading参数来运行上面的代码，跟踪它的加载顺序，部分输出日志如下：

[Loaded cn.shinelon.jvm.Parent from file:/G:/ProgramFiles/eclipsefile/JVM/bin/]
[Loaded cn.shinelon.jvm.Child from file:/G:/ProgramFiles/eclipsefile/JVM/bin/]
parent init
100
[Loaded java.lang.Shutdown from C:\Program Files\Java\jre1.8.0_161\lib\rt.jar]
[Loaded java.lang.Shutdown$Lock from C:\Program Files\Java\jre1.8.0_161\lib\rt.jar]

在这里需要额外注意一下，上面提到加载一个类的时候，需要它的父类全部被加载过，但是接口除外，也就是说一个接口初始化的时候，并不要求其父接口全部都完成初始化，只有在真正使用到父接口的时候才会被初始化。

加载类

加载类的时候，虚拟机需要完成下面三件事：

1. 通过类的全名，获取类的二进制数据流。
2. 解析类的二进制数据流为方法区内的数据结构。
3. 创建java.lang.Class类的实例，表示该类型。

对于类的二进制数据流，虚拟机可以通过多种途径产生或者获取，虚拟机可能通过文件系统读入一个class后缀的文件或者也可能读入JAR，ZIP等归档数据包，提取类文件，除了这些形式外，任何形式都是可以的，比如，事先将类的二进制数据存放在数据库中，或者童年各国HTTP协议在网络中传输进行加载等，甚至是运行时动态生生class的二进制信息都可以。

数组类的加载与普通类的加载有所不同，数组类本身不通过类加载器创建，它是由java虚拟机直接创建的，但是数组类的元素类型（指去掉数组所有维度的类型）最终还是要靠类加载器去创建的。一个数组类的加载过程遵循下面的规则：

1. 如果数组的组件类型（指去掉一个维度的类型）是引用类型，那就递归采用上面提到的加载过程去加载这个组件类型。
2. 如果 数组的组件类型不是引用类型（如果int[]数组），那么java虚拟机将会把数组标记为与引导类加载器关联。
3. 数组类的可见性与它的组件类型的可见性一致，如果组件类型不是引用类型，那么数组类的可见性将默认为public。

在加载完成之后，二进制字节流将按照虚拟机所需的格式存储在方法区之中（java8中变为了元数据区），然后内存中实例化一个java.lang.Class类的对象，值得注意的是，它虽然是对象，但是存放在方法区中。该对象也是实现反射的基础，例如下面一个简单的示例来获取java.lang.String类的所有方法信息并且打印出来：

public class TestClass {
	public static void main(String[] args) throws ClassNotFoundException {
		Class clzStr=Class.forName("java.lang.String");
		Method[] method=clzStr.getDeclaredMethods();
		for(Method m:method){
			String mod=Modifier.toString(m.getModifiers());
			System.out.print(mod+" "+m.getName()+" (");
			Class<?>[] ps=m.getParameterTypes();
			if(ps.length==0)
				System.out.print(")");
			for(int i=0;i<ps.length;i++){
				char end=i==ps.length-1?')':',';
				System.out.println(ps[i].getSimpleName()+end);
			}
			System.out.println();
		}
	}
}

验证

当类加载到系统之后，就开始连接操作，验证是连接操作的第一步，它的目的是保证加载的字节码是合法，合理并且符合规范的，它主要格式检查（如魔术检查，版本检查，长度检查）、语义检查（如是否继承final，是否有父类，抽象方法是否实现）、字节码验证（图跳转指令是否指向正确的位置 ，操作数类型是否合理）、符合引用验证（符号引用的直接引用是否存在）。

1. 首先必须判断类的二进制数据是否是符合格式要求和规范的。比如，是否以魔术0XCAFEBABE开头，主版本号和小版本号是否在当前java虚拟机的支持范围内，数据中的每一项是否都拥有正确的长度等等。
2. java虚拟机会进行字节码的语义检查，比如是否通过所有类都有的父类的存在，是否一些被定义为final的方法或者类被加载或者继承了，非抽象类是否实现了所有的抽象方法或者接口方法等，即对语义上不符合规范的程序不给予通过。
3. 接着还会进行字节码的验证，字节码的验证也是验证过程中最复杂的一个过程，它试图通过对字节码流的分析，判断 字节码是否可以被正确地执行。比如 ，在字节码的执行过程中，是否会跳转到一条不存在的指令，函数的调用是否传递了正确的类型的参数，变量的赋值是否给出了正确的数据类型等。
4. 最后还会进行符号引用的验证，Class文件在其常量池中会通过字符串记录自己将要使用的其他类或者方法，它会检查这些类或者方法确实是存在的，如果一个类无法在系统中找到，它会抛出NoClassDefFoundError，如果一个方法没有被找到时，则会抛出NoSuchMethodError。

准备

准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区进行分配（这里的变脸仅指类变量）。例如：

public static int value=100;

这个变量在初始化阶段之后的初始值为0而不是100，因为这个时候尚未开始执行任何java方法，而赋值为100的操作是进行编译执行初始化阶段才会执行的。

解析

在准备阶段完成之后，就进入到了解析阶段，这个 阶段的工作就是将类、接口、字段和方法的符号引用转为直接引用。这里需要明白符号引用和直接引用的区别：

1. 符号引用：符号引用就是以一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可。符号引用与虚拟机实现的内存布局无关，引用的目标并不一定 已经加载到内存中。各种虚拟机实现的内存布局可以各不相同，但是它们能接受的符号引用必须是一致的，因为符号引用的字面量形式明确定义在java虚拟机规范的class文件中。
2. 直接引用：直接引用可以使直接指向目标的指针，相对偏移量或者一个能间接定位到目标的句柄。直接引用是和虚拟机实现的内存布局相关的，同一个符号引用在不同虚拟机上翻译出来的直接引用一般不会相同。如果有了直接引用，那么引用的目标必定已经在内存中存在了。

以一个方法调用为例，java 虚拟机为每一个类都准备了一张方法表，将其所有的方法都列在表中，当需要调用一个类的方法的时候，只要知道这个方法在方法表中的偏移量就可以直接调用该方法了。因此，符号引用转为直接引用，也就是得到类或者字段，方法在内存中的指针或者偏移量，所以，如果直接引用存在，那么可以肯定系统中存在该类，或者方法字段，但是只存在符号引用，不能确定是否存在该对象。

初始化

类的初始化时类装载的最后一个阶段，如果前面的步骤没有问题，那么表示类的顺利加载到该系统中，此时，类才会开始被执行。初始化阶段最重要的工作是执行类的初始化方法。方法是由编译器自动生成的，它是由类的静态成员的赋值语句以及static语句块合并产生的。需要注意 以下几点：

1. 静态语句块中只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块中可以赋值，但是不能访问。
2. 子类的方法执行之前，父类的方法已经执行完毕。
3. 方法不是必须的，也就是说如果一个类或者接口中，没有静态语句块，或者没有对变量的赋值操作，那么编译器可以不为这个类生成方法。
4. 接口中没有静态语句块，单任然有变量初始化的赋值操作，所以也会生成方法，不同于类的是，它在父接口只在使用时才会初始化，初始化子接口的时候不会去初始化父类。
5. 虚拟机保证一个类的方法在多线程环境中被正确 的加锁，同步执行，其他的线程曾会被阻塞等待，直到活动线程执行方法完毕，如果类已经被加载，直接返回。

上面被提到，类的加载过程是线程安全的，所有，这也有可能会引起死锁，如下示例展示出类加载过程中死锁的问题：

public class StaticA {
	
	static{
		try {
			Thread.sleep(1000);
			Class.forName("cn.shinelon.jvm.StaticB");
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("Static A init ok");
	}

}

public class StaticB {
	static{
		try {
			Thread.sleep(1000);
			Class.forName("cn.shinelon.jvm.StaticA");
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("StaticB init OK");
	}
}

public class TestLoadLock extends Thread{
	private char flag;
	
	public TestLoadLock(char flag){
		this.flag=flag;
		this.setName("Thread"+flag);
	}
	
	@Override
	public void run() {
		try {
			Class.forName("cn.shinelon.jvm.Static"+flag);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		System.out.println(getName()+" over");
	}
	
	public static void main(String[] args) {
		TestLoadLock lockA=new TestLoadLock('A');
		lockA.start();
		TestLoadLock lockB=new TestLoadLock('B');
		lockB.start();
	}
	
}

运行 上面代码发现产生死锁，使用jstack工具打印堆栈信息如下：