JVM第七章-虚拟机类加载机制

本文介绍: 那。

代码编译的结果从本地机器码转变为字节码，本章涉及虚拟机如何加载这些Class文件，Class文件中的信息进入到虚拟机后会发生什么变化
类加载机制
Jav a 虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。
类加载的时机
一个类型从被加载到虚拟机内存中到卸载出内存的整个生命周期
在这里插入图片描述
加载、验证、准备、初始化和卸载这五个阶段的顺序是确定的，类型的加载过程必须按
照这种顺序按部就班地开始。而解析阶段则不一定：它在某些情况下可以在初始化阶段之后再开始，这是为了支持Java语言的运行时绑定特性（也称为动态绑定或晚期绑定）。为这些阶段通常都是互相交叉地混合进行的，会在一个阶段执行的过程中调用、激活另一个阶段
初始化开始的情况：
1）遇到new、get static、putstatic或in vokestatic这四条字节码指令时，如果类型没有进行过初始化，则需要先触发其初始化阶段。能够生成这四条指令的典型Java代码场景有：
·使用new关键字实例化对象的时候。
·读取或设置一个类型的静态字段（被final 修饰、已在编译期把结果放入常量池的静态字段除外）
的时候。
·调用一个类型的静态方法的时候。
2）使用 java.lang.reflect包的方法对类型进行反射调用的时候，如果类型没有进行过初始化，则需要先触发其初始化
3）当初始化类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
4）当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先
初始化这个主类
5）动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果为REF_getStatic、REF_putStatic、REF_invokeStatic、REF_newInvokeSpecial四种类型的方法句柄，并且这个方法句柄对应的类没有进行过初始化，则需要先触发其初始化。（什么是动态语言支持？）
6）当一个接口中定义了JDK 8新加入的默认方法（被default关键字修饰的接口方法）时，如果有这个接口的实现类发生了初始化，那该接口要在其之前被初始化。
这六种场景中的行为称为对一个类型进行主动引用。除此之外，所有引用类型的方式都不会触发初始化，称为被动引用。
被动引用的例子
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 NotInitialization {
public static void main(String[] args) {
System.out.println(SubClass.value);
}
}

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

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

运行之后发现没有输出“SuperClass init！”
3.常量在编译阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此不会触发定义常量的
上述代码运行之后，也没有输出“ConstClass init！”，这是因为虽然在Java源码中确实引用了
ConstClass类的常量HELLOWORLD，但其实在编译阶段通过常量传播优化，已经将此常量的值“helloworld”直接存储在NotInitialization类的常量池中，以后NotInitialization对常量ConstClass.HELLOWORLD的引用，实际都被转化为NotInitialization类对自身常量池的引用了。也就是说，实际上NotInitialization的Class文件之中并没有ConstClass类的符号引用入口，这两个类在编译成Class文件后就已不存在任何联系了。

在加载阶段，Java虚拟机需要完成以下三件事情：
1）通过一个类的全限定名来获取定义此类的二进制字节流。
2）将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
3）在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。
非数组类型的加载阶段可以使用Java虚拟机里内置的引导类加载器来完成，也可以由用户自定义的类加载器去完成
数组类的加载如下：（没懂）
数组类本身不通过类加载器创建，它是由Java虚拟机直接在内存中动态构造出来的。但数组类的元素类型（ElementType，指的是数组去掉所有维度的类型）最终还是要靠类加载器来完成加载
其创建流程遵循以下规则
1.如果数组的组件类型是引用类型，就递归采用本节中定义的加载过程去加载这个组件类型，数组C将被标识在加载该组件类型的类加载器的类名称空间上
2.如果数组的组件类型不是引用类型（例如int[]数组的组件类型为int），Java虚拟机将会把数组C
标记为与引导类加载器关联。
加载阶段与连接阶段的部分动作（如一部分字节码文件格式验证动作）是交叉进行的，加载阶段
尚未完成，连接阶段可能已经开始。

这一阶段的目的是确保Class文件的字节流中包含的信息符合《Java虚拟机规范》的全部约束要求
大致上会完成下面四个阶段的检验动作：文件格式验证、元数据验证、字节码验证和符号引用验证。
虚拟机验证到输入的字节流如不符合Class文件格式的约束，就应当抛出一个java.lang.VerifyError异常或其子类异常
文件格式验证
该验证阶段的主要目的是保证输入的字节流能正确地解析并存储于方法区之内，格式上符合描述一个Java类型信息的要求。这阶段的验证是基于二进制字节流进行的，只有通过了这个阶段的
验证之后，这段字节流才被允许进入Java虚拟机内存的方法区中进行存储，所以后面的三个验证阶段全部是基于方法区的存储结构上进行的
元数据验证
第二阶段是对字节码描述的信息进行语义分析，以保证其描述的信息符合《Java语言规范》的要
求
字节码验证
目的是通过数据流分析和控制流分析，确定程序语义是合法的、符合逻辑的。该阶段对类的方法体（Class文件中的Code属性）进行校验分析，保证被校验类的方法在运行时不会做出危害虚拟机安全的行为，但不可能用程序来准确判定一段程序是否存在Bug
符号引用验证
发生在虚拟机将符号引用转化为直接引用的时候，这个转化动作将在连接的第三阶段——解析阶段中发生。目的是对类自身以外（常量池中的各种符号引用）的各类信息进行匹配性校验，通俗来说就是，该类是否缺少或者被禁止访问它依赖的某些外部类、方法、字段等资源。
如果无法通过符号引用验证，Java虚拟机将会抛出一个java.lan g.IncompatibleClassChangeError的子类异常，典型的如：java.lang.IllegalAccessError、java.lang.NoSuchFieldError、java.lang.NoSuchMethodError等

准备阶段是正式为类中定义的变量（即静态变量，被static修饰的变量）分配内存并设置类变量初
始值的阶段。在JDK 7及之前，HotSpot使用永久代来实现方法区时，实现是完全符合这种逻辑概念的；而在JDK 8及之后，类变量则会随着Class对象一起存放在Java堆中。这时候进行内存分配的仅包括类变量，而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在Java堆中。类变量在准备阶段过后的初始值为0值，但如果类变量是Constant的话，在准备阶段虚拟机会赋值为最终的常量值

public class ClassLoaderTest {
public static void main(String[] args) throws Exception {
	ClassLoader myLoader = new ClassLoader() {
	@Override
	public Class<?> loadClass(String name) throws ClassNotFoundException {
	try {
		String fileName = name.substring(name.lastIndexOf(".") + 1)+".class";
		InputStream is = getClass().getResourceAsStream(fileName);
		if (is == null) {
			return super.loadClass(name);
		}
		byte[] b = new byte[is.available()];
		is.read(b);
		return defineClass(name, b, 0, b.length);
	} catch (IOException e) {
		throw new ClassNotFoundException(name);
	}
}
};
	Object obj =myLoader.loadClass("org.fenixsoft.classloading.ClassLoaderTest").newInstance();
	System.out.println(obj.getClass());
	System.out.println(obj instanceof org.fenixsoft.classloading.ClassLoaderTest);
}
}

class org.fenixsoft.classloading.ClassLoaderTest
false

public ClassLoader getClassLoader() {
	//获取当前类的类加载器
	ClassLoader cl = getClassLoader0();
	//如果getClassLoader0()返回null，则表示当前类是由启动类加载器加载的。
	if (cl == null)
		return null;
	//安全检查
	SecurityManager sm = System.getSecurityManager();
	if (sm != null) {
		ClassLoader ccl = ClassLoader.getCallerClassLoader();
	if (ccl != null &amp;&amp; ccl != cl && !cl.isAncestor(ccl)) {
		sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
	}
}
//返回当前类的类加载器
return cl;
}

protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException
{
	// 首先，检查请求的类是否已经被加载过了
	Class c = findLoadedClass(name);
	if (c == null) {
		try {
			if (parent != null) {
				//若没有则调用父加载器的loadClass()方法
				c = parent.loadClass(name, false);
			} else {
			//若父加载器为空则默认使用启动类加载器作为父加载器
				c = findBootstrapClassOrNull(name);
			}
			} catch (ClassNotFoundException e) {
			// 如果父类加载器抛出ClassNotFoundException
			// 说明父类加载器无法完成加载请求
			}
			//假如父类加载器加载失败，抛出ClassNotFoundException异常的话，才调用自己的findClass()方法尝试进行加载
			if (c == null) {
				// 在父类加载器无法加载时
				// 再调用本身的findClass方法来进行类加载
				c = findClass(name);
			}
			}
			if (resolve) {
				resolveClass(c);
			}	
			return c;
}