JVM类加载机制深度解析

类加载运行过程

package com.wetest.jvm;
public class Math {
	public static final int initData = 666;
	public static User user = new User();
	public int add(){
		int a = 1;
		int b = 2;
		return a + b;
	}
	public static void main(String[] args) {
		Math math = new Math();
		math.add();
	}
}

通过java命令执行代码大致流程如下：

1、加载

加载包括三件事情：
①：通过一个类的全限定类名来获取此类的二进制字节流
②：将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
③：在内存中生成一个代表这个类的java.lang.class对象，作为方法区这个类的各种数据的访问入口

2、验证

检验字节码文件是否符合JVM的指令码规范

3、准备

给类的静态变量分配内存，并赋予默认值

4、解析

将符号引用替换为直接引用，该阶段会把一些静态方法（符号引用，比如main()方法）替换为指定数据所存内存的指针或句柄等（直接引用），这是所谓的静态链接过程，动态链接是将程序运行期间完成的符号引用替换为直接引用

5、初始化

将类的静态变量初始化为指定的值，执行静态代码块

类加载器

引导类加载器

负责加载支撑JVM运行的JRE目录下的lib中的核心类库，比如：rt.jar

扩展类加载器

负责加载支撑JVM运行的JRE目录下的lib中的ext扩展目录的jar包

自定义加载器

负责加载用户自定义路径下的类包

类加载器的初始化过程

类加载器初始化过程： 参见类运行加载全过程图可知其中会创建JVM启动器实例sun.misc.Launcher。 sun.misc.Launcher初始化使用了单例模式设计，保证一个JVM虚拟机内只有一个 sun.misc.Launcher实例。 在Launcher构造方法内部，其创建了两个类加载器，分别是 sun.misc.Launcher.ExtClassLoader(扩展类加载器)和sun.misc.Launcher.AppClassLoader(应用类加载器)。 JVM默认使用Launcher的getClassLoader()方法返回的类加载器AppClassLoader的实例加载我们的应用程序。

双亲委派机制

JVM类加载器是有亲子层结构的，如下图

双亲委派说明：
加载某个类的时候会先委托父加载器寻找目标类，找不到再委托上层父加载器加载，如果所有的父加载器在自己的加载器中都找不到这个目标类，则在自己的类加载路径中查找并载入目标类

应用类加载器AppClassLoader加载类的源码：

//ClassLoader的loadClass方法，里面实现了双亲委派机制
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
	synchronized (getClassLoadingLock(name)) {
		// 检查当前类加载器是否已经加载了该类 
		Class<?> c = findLoadedClass(name); 
		if (c == null) { 
			long t0 = System.nanoTime();
			try {
				if (parent != null) { 
					//如果当前加载器父加载器不为空则委托父加载器加载该类 
					c = parent.loadClass(name, false); 
				} else { 
					//如果当前加载器父加载器为空则委托引导类加载器加载该类 
					c = findBootstrapClassOrNull(name);
				}
			} catch (ClassNotFoundException e) {
				// ClassNotFoundException thrown if class not found 
				// from the non‐null parent class loader
			} 
			if (c == null) {
				// If still not found, then invoke findClass in order 
				// to find the class.
				long t1 = System.nanoTime(); 
				//都会调用URLClassLoader的findClass方法在加载器的类路径里查找并加载该类 
				c = findClass(name); 
				// this is the defining class loader; record the stats    
				sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 ‐ t0);
				sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1); 
				sun.misc.PerfCounter.getFindClasses().increment(); 
			} 
		}
		if (resolve) { 
			//不会执行 
			resolveClass(c);
		}
		return c; 
	}
}       		

为什么要设计双亲委派机制？

沙箱安全机制：自己写的java.lang.String.class类不会被加载，这样便可以防止核心 API库被随意篡改
避免类的重复加载：当父亲已经加载了该类时，就没有必要子ClassLoader再加载一 次，保证被加载类的唯一性

全盘负责委托机制

全盘负责是指一个ClassLoader装载一个类时，除非显示的使用另外一个ClassLoader，该类所依赖及引用的类也由这个ClassLoader载入。

自定义类加载器示例：

自定义类加载器只需要继承java.lang.ClassLoader类，该类有两个核心方法，一个是loadClass(String, boolean)，实现了双亲委派机制，还有一个方法是findClass，默认实现是空方法，所以我们自定义类加载器主要是重写findClass方法。

public class MyClassLoderTest{
	
    static class MyClassLoader extends ClassLoader{
        private String classPath;
        public MyClassLoader(String classPath){
            this.classPath = classPath;
        }
        private byte[] loadByte(String name) throws Exception{
            name = name.replaceAll("\\.","/");
            FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");
            int len = fis.available();
            byte[] data = new byte[len];
            fis.read(data);
            fis.close();
            return data;
        }
        protected Class<?> findClass(String name) throws ClassNotFoundException{
            try{
                byte[] data = loadByte(name);
                // defineClass将一个字节数组转化为Class对象，这个字节数组是class文件读取后最终的字节数组。
                return defineClass(name, data, 0, data.length);
            }catch(Exception e){
                throw new ClassNotFoundException();
            }
        }
    }

    public static void main(String args[]) throws Exception{
        //初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器的父加载器设置为应用程序类加载器AppClassLoader
        MyClassLoader classLoader = new MyClassLoader("D:/test");
        // D盘创建test/com/wetest/jvm 几级目录，将Math类丢入该目录(并且删掉原来的项目中的编译好的Math.class文件，为了不让父类应用程序类加载器去加载)
        Class clazz = classLoader.loadClass("com.wetest.jvm.Math");
        Object obj = clazz.newInstance();
        Method method = clazz.getDeclaredMethod("add",null);
        method.invoke(obj, null);
        System.out.println(clazz.getClassLoader().getClass().getName());
    }
}
//运行结果
com.wetest.jvm.MyClassLoaderTest$MyClassLoader

打破双亲委派机制

如果需要打破双亲委派机制就需要重写loadClass方法，在自定义类加载器中，去掉父类加载器加载的逻辑，并且添加自己逻辑，jdk内部的类由于沙箱安全机制只能让父类去加载之外，其他自己写的类使用自己的类加载器是加载，loadClass代码如下

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        // First, check if the class has already been loaded
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            long t0 = System.nanoTime();

            // If still not found, then invoke findClass in order
            // to find the class.
            long t1 = System.nanoTime();
            if(!name.startsWith("com.wetest.jvm")){
                c = this.getParent().loadClass(name);
            }else {
                c = findClass(name);
            }

            // this is the defining class loader; record the stats
            sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
            sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
            sun.misc.PerfCounter.getFindClasses().increment();
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

终于有点时间写写自己的博客，欢迎大家评价