JVM的类加载机制和类加载过程

JVM的启动与销毁

类的加载,链接,初始化
系统可能在第一次使用某个类时加载该类,也可能采用预加载机制来加载某个类
JVM和类
当调用java命令运行某个Java程序是,该命令会启动一个Java虚拟机进程,无论
该Java程序有多么复杂,给程序启动了多少个线程,他们都处于Java虚拟机进程java

同一个JVM的全部线程、全部变量都处于同一个进程里,他们都是用该JVM进程
的内存区,当系统出现如下几种状况时,JVM进程将被终止
1.程序运行到最后正常结束
2.程序运行到System.exit()或者Runtime.getRuntime().exit()代码结束程序
3.程序执行过程当中遇到未捕获的异常或错误而结束
4.程序所在的平台强制结束了JVM进程
JVM进程结束,该进程在内存中的状态将会丢失程序员

举例代码web

public class JVM1 {

	public static void main(String[] args) {
		A a = new A();
		a.a++;
		System.out.println(a.a);
	}

}
class A {
	public static int a = 10;
}

结果：
数据库

package com.zhouym.day_0507;

public class JVM2 {

	public static void main(String[] args) {
		A b = new A();
		System.out.println(b.a);

	}

}

结果

上述是两个虚拟机进程，当第一个运行结束，进程便会销毁，第二个运行时从新加载编程

类加载

当程序主动使用某个类时,若是该类还未被加载到内存中,则系统会经过加载、链接、初始化
三个步骤来对该类进行初始化,若是没有意外,JVM会连续完成这三个步骤,因此有的时候把这三个
步骤统称为类加载或者类初始化数组

Class类
类是对一批对象的抽象,可是类也是一种对象,就例如概念是用来描述事物的,可是概念自己也是一种事物
因此概念自己也须要被描述
因此描述类的类在Java中就叫作Class,在java.lang.Class包下缓存

类加载器
类的加载由类加载器完成,类加载器一般由JVM提供,这些类加载器也是前面全部程序运行的基础,
JVM提供的这些类加载器统称成为系统类加载器,除此以外,开发者能够经过继承ClassLoader基类
来建立本身的类加载网络

经过使用不一样的类加载器,能够从不一样来源加载类的二进制数据,一般有以下几种来源
1.从本地文件系统加载class文件,这是前面绝大部分示例程序的类加载方式
2.从JAR包加载class文件,这种方式也是很常见的,前面介绍JDBC编程时用到的数据库驱动类就放在
JAR文件中,JVM能够从JAR文件中直接加载该class文件
3.经过网络加载class文件
4.把一个Java件动态编译,并执行加载
类加载器一般无须等到"首次使用"该类时才加载该类,Java虚拟机规范容许系统预先加载某些类ide

类链接

当类被加载以后,系统为之生成一个Class对象,接着将会进入链接阶段,链接阶段负责把类的二进制
数据合并到JRE中,类链接又可分为以下三个阶段
1.验证: 验证阶段用于检验被加载的类是否有正确的内部结构,并和其余类协调一致
2.准备: 类准备阶段则负责为类的类变量分配内存,并设置默认值
3.解析: 将类的二进制数据中的符号引用替换成直接引用svg

类的初始化

在类的初始化阶段,虚拟机负责对类进行初始化,主要就是对类变量进行初始化
对类变量进行初始化的方式有两种:
1.声明类变量时指定初始值
2.使用静态代码块为类变量指定初始化值
注意: 声明类变量时指定初始值以及使用静态代码块为类变量指定初始化值时,JVM会按照语句在程序中的排列顺序依次执行它们.
JVM初始化一个类包含以下几个步骤
1.假如这个类尚未被加载和链接,则程序先加载并链接该类
2.假如该类的直接父类尚未被初始化,则先初始化其直接父类
3.假如类中有初始化语句,则系统依次按照顺序执行这些初始化语句
4.当执行第二步骤时,系统对直接父类的初始化步骤也遵循1~3,若是直接父类又有直接父类,
则系统再次重复这三个步骤来初始化父类…依次类推,因此JVM最早初始化的老是Object类
注意: 当程序主动使用任何一个类时,系统会保证该类或者该类的全部的父类都被初始化

类的初始化时机
当Java程序首次经过下面6种方式来使用某个类或者接口的时候,系统就会初始化该类或接口
1.建立类的实例,为某个类建立实例的方式包括: 使用new操做符来建立实例,经过反射来建立实例,经过反序列化来建立实例
2.调用某个类的类方法
3.访问某个类的类变量或者为该类变量赋值
4.使用反射方式来强制建立某个类或者接口对应的Class对象
5.初始化某个类的子类,当初始化某个类的子类时,该子类的全部父类都会被初始化
6.直接使用java.exe命令来运行某个主类,当运行某个主类时,程序会先初始化该主类

注意:
1.final修饰的类变量,若是该类变量在编译时期就能够肯定下来,那么这个类变量至关于"宏变量",Java编译器会在编译时
直接把这个类变量出现的地方替换成它的值,所以即便程序使用该静态变量,也不会致使该类被初始化
2.当使用ClassLoader类的loadClass方法来加载某个类时,该方法只是加载该类,并不会执行类的初始化,使用
Class.forName()静态方法才会致使强制初始化该类

类加载器

类加载器是用来将.class文件(多是磁盘上,也多是网络上)加载到内存中,并为之生成对应的Class对象

类加载机制
类加载器负责载入全部的类,系统为全部被载入内存中的类生成一个Class实例
在Java中,一个类使用其全限定类名(包括包名和类名)做为惟一标识
在JVM中,一个类使用其全限定类名(包括包名和类名)和类加载做为惟一标识

JVM启动时,会造成由三个类加载器组成的初始类加载器层次结构
Bootstrap ClassLoader 根类加载器
Extension ClassLoader 扩展类加载器
System ClassLoader 系统类加载器

Bootstrap ClassLoader成为根类加载器/引导类加载器/原始类加载器,负责加载Java的核心类.
在执行java.exe命令时,使用-Xbootclasspath 或 -D选项指定sun.boot.class.path系统
属性值能够指定加载附加的类

JVM的类加载机制有以下三种状况
1.父类委托: 尝试先让父类加载器加载,父类加载器没法加载,尝试本身的类路径下加载
2.全盘负责: 加载某个Class的时候,该Class所依赖的和引用的其余Class都由该类加载器载入
3.缓存机制: 全部加载过的Class都会被缓存,当程序须要用到某个Class的时候,如今缓存中搜索
是否存在,不存在就读取而且转换成Class对象保存到缓冲区中,这就是为何Class文件修改后须要
从新启动JVM,程序修改才会生效

用户类加载器 --> 系统类加载器 --> 扩展类加载器 --> 根类加载器
自定义类加载器经过继承ClassLoader类来实现

获取JVM的类加载器
ClassLoader systemLoader = ClassLoader.getSystemClassLoader();
Enumeration resources = systemLoader.getResources("");
ClassLoader parent = systemLoader.getParent();
System.getProperty(“java.ext.dirs”);

注意: 扩展类加载器的父类是null,并非根类加载器,这是由于根类加载器并无继承ClassLoader
抽象类,因此扩展类加载器的getParent方法返回null,可是实际上扩展类加载器的父类加载器是
根类加载器,只是根类加载器并非Java实现的,Java程序员也无需访问根类加载器

类加载器过程

1.检测此Class是否载入过(即在缓存区中是否有Class),若是有则直接进入第8步,不然执行第2步
2.若是父类加载器不存在(若是没有父类加载器,要么parent是根类加载器,要么本身自己就是根类加载器)
则进入第4步执行,若是父类加载器存在,则执行第3步
3.请求使用父类加载器去载入目标类,若是成功载入,则进入第8步执行,不然接着执行第5步
4.请求根类加载器来载入目标类,若是成功载入就进入第8步执行,不然跳到第7步
5.当前类加载器尝试寻找Class文件(今后ClassLoader相关的类路径中寻找),若是找到
执行第6步,若是找不到则跳到第7步
6.从文件中载入Class,载入成功后跳到第8步
7.抛出ClassNotFoundException异常
8.返回对应的java.lang.Class对象

注意: 其中第5,6步容许重写ClassLoader的findClass方法来实现本身的载入策略,甚至能够重写
loadClass方法来实现本身的载入过程
举例代码以下

public class ReflectDemo {
   public static void main(String[] args) throws IOException {
   	// 获取系统类加载器
   	ClassLoader systemLoader = ClassLoader.getSystemClassLoader();
   	System.out.println("系统类加载器: " + systemLoader);
   	
   	Enumeration<URL> resources = systemLoader.getResources("");
   	while (resources.hasMoreElements()) {
   		URL url = resources.nextElement();
   		System.out.println(url);
   	}
   	
   	ClassLoader parent = systemLoader.getParent();
   	System.out.println(parent);
   	System.out.println("扩展类加载器的加载路径: " + System.getProperty("java.ext.dirs"));
   	
   	System.out.println("根类加载器: " + parent.getParent());
   }
}

自定义类加载器
JVM中除了根类加载器以外的全部类加载器都是ClassLoader子类的实例,开发者能够
扩展ClassLoader的子类,而且重写ClassLoader所包含的方法来实现自定义的类
加载器。其中有两个关键方法
loadClass:根据指定名称来加载类,系统就是调用此方法来获取指定类对应的Class对象
findClass:根据指定名称来查找类
defindClass(String,byte[],int,len): 该方法负责将指定类的字节码文件
读入字节数组byte[]内,并把它转换为Class对象,该字节码文件能够来自于文件/网络中
find.SystemClass(String): 从本地文件系统装入文件。它在本地系统中寻找类文件,
若是存在,就使用defineClass方法将原始字节转换成Class对象,以将改文件转换成类
static getSystemClassLoader(): 返回系统类加载器对象
getParent: 获取该类加载器的父类加载器
resolveClass(Class): 连接指定的类,类加载器可使用该方法连接类文件
findLoadedClas(String): 来检查是否已经加载类,若是已经加载则直接返回
一般都是重写findClass方法

loadClass方法的执行步骤以下:
1.使用findLoadedClas(String)来检查是否已经加载类,若是已经加载则直接返回
2.在父类加载器上调用loadClass方法,若是父类加载器为null,则使用根类加载器加载
3.调用findClass(String)方法查找类

从上述步骤能够看出,重写findClass方法能够避免覆盖类加载的双亲委派机制和缓冲机制
两种方法,若是想要本身重写loadClass方法,则实现逻辑很是复杂
举例代码以下

public class CompileClassLoader extends ClassLoader {
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		if (args.length < 1) {
			System.out.println("缺乏目标类 请按照以下格式运行Java文件");
			System.out.println("java compileClassLoader ClassName");
		}
		String proClass = args[0];
		String[] progArgs = new String[args.length - 1];
		System.arraycopy(args, 1, progArgs, 0, progArgs.length);
		CompileClassLoader ccl = new CompileClassLoader();
		Class<?> clazz = ccl.loadClass(proClass);
		Method main = clazz.getMethod("main", (new String[0]).getClass());
		Object argsArray[] = {progArgs};
		main.invoke(null, argsArray);
	}
	// 读取文件内容
	private byte[] getBytes(String fileName) {
		File file = new File(fileName);
		long len = file.length();
		byte[] bys = new byte[(int) len];
		try {
			FileInputStream fis = new FileInputStream(file);
			int r = fis.read(bys);
			
			if (r != len) {
				throw new IOException("没法读取所有文件");
			}
			
			return bys;
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		return null;
	}
	
	// 定义编译指定Java文件的方法
	private boolean compile(String javaFile) {
		System.out.format("正在编译%s文件,请稍后...", javaFile);
		// 调用javac命令
		try {
			Process process = Runtime.getRuntime().exec("javac " + javaFile);
			process.waitFor();
			int ret = process.exitValue();
			return ret == 0;
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return false;
	}
	
	// 重写ClassLoader的findClass方法
	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		Class<?> clazz = null;
		String fileStub = name.replace(".", "/");
		String javaFileName = fileStub + ".java";
		String classFileName = fileStub + ".class";
		File javaFile = new File(javaFileName);
		File classFile = new File(classFileName);
		if (javaFile.exists() && (!classFile.exists() || javaFile.lastModified() > classFile.lastModified())) {
			try {
				if (!compile(javaFileName) || !classFile.exists()) {
					throw new ClassNotFoundException("ClassNotFoundException:" + javaFileName);
				}
			} catch (Exception e) {
				// TODO: handle exception
			}
		}
		
		if (classFile.exists()) {
			byte[] raw = getBytes(classFileName);
			clazz = defineClass(name, raw, 0, raw.length);
		}
		
		if (clazz == null) {
			throw new ClassNotFoundException(name);
		}
		
		return clazz;
	}
}