JVM篇之类加载机制

1.概述

刚开始学java时，我们应该都听过一句话，java跨平台运行，一次编译，处处运行；Java类最终都会变编译成class文件，运作在我们的虚拟机JVM上，那class文件是怎么运行的呢？

2.类加载过程

先来看一下JVM的整体架构模型：

从上图可以很清晰的看出，jvm架构分成三大部分

类加载子系统：就是下面要讲的内容
运行时数据区：常说程序运行时分配的堆、方法区、栈等等所在的区域
执行引擎：包含解释器、编译器、垃圾回收器等

想必我们现在对JVM的整体架构有了一个初步认识,那接着往下看.

类的加载指的是将磁盘中类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个java.lang.Class对象，用来封装类在方法区内的数据结构。类的加载的最终产品是位于堆区中的Class对象，Class对象封装了类在方法区内的数据结构，并且向Java程序员提供了访问方法区内的数据结构的接口。整个过程如下：

1.加载：在硬盘上查找并通过IO读入字节码文件，使用到类时才会加载，例如调用类的main()方法，new对象等等，在加载阶段会在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口
2.验证：校验字节码文件的正确性
3.准备：给类的静态变量分配内存，并赋予默认值
4.解析：将符号引用替换为直接引用，该阶段会把一些静态方法(符号引用，比如main()方法)替换为指向数据所存内存的指针或句柄等(直接引用)，这是所谓的静态链接过程(类加载期间完成)，动态链接是在程序运行期间完成的将符号引用替换为直接引用
5.初始化：对类的静态变量初始化为指定的值，执行静态代码块
类被加载到方法区中后主要包含 运行时常量池、类型信息、字段信息、方法信息、类加载器的引用、对应class实例的引用等信息。
类加载器的引用：这个类到类加载器实例的引用
对应class实例的引用：类加载器在加载类信息放到方法区中后，会创建一个对应的Class 类型的对象实例放到堆(Heap)中, 作为开发人员访问方法区中类定义的入口和切入点。
6.最后就是类的使用和卸载

注意：主类在运行过程中如果使用到其它类，会逐步加载这些类，jar包或war包里的类不是一次性全部加载的，是使用到时才加载

3.双亲委派机制

刚才我们说了类加载的过程，那这些类是怎么被加载的呢？没错，JVM的类加载器。

前面三个类加载器都是java自己的类加载器，下面简单讲一下我们自定义类加载器。

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

public class MyClassLoaderTest {
    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) {
                e.printStackTrace();
                throw new ClassNotFoundException();
            }
        }

    }

    public static void main(String args[]) throws Exception {
        //初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器的父加载器设置为应用程序类加载器AppClassLoader
        MyClassLoader classLoader = new MyClassLoader("D:/test");
        //D盘创建 test/com/demo 几级目录，将自定义类User.class丢入该目录
        Class clazz = classLoader.loadClass("com.demo.User");
        System.out.println(clazz.getClassLoader().getClass().getName());
    }
}

运行结果：
com.demo.MyClassLoaderTest$MyClassLoader

双亲委派机制其实就是加载某个类时会先委托父加载器寻找目标类，找不到再委托上层父加载器加载，如果所有父加载器在自己的加载类路径下都找不到目标类，则在自己的类加载路径中查找并载入目标类，每一层在找到目标类之后，直接加载返回。

思考一下，我们为什么要使用双亲委派机制这么多类加载器去加载class呢？为何不用一个类加载器去加载，要搞的这么麻烦？

我们来看下应用程序类加载器AppClassLoader加载类的双亲委派机制源码，AppClassLoader的loadClass方法最终会调用其父类ClassLoader的loadClass方法，该方法的大体逻辑如下：
首先，检查一下指定名称的类是否已经加载过，如果加载过了，就不需要再加载，直接返回。
如果此类没有加载过，那么，再判断一下是否有父加载器；如果有父加载器，则由父加载器加载（即调用parent.loadClass(name, false);）.或者是调用bootstrap类加载器来加载。
如果父加载器及bootstrap类加载器都没有找到指定的类，那么调用当前类加载器的findClass方法来完成类加载

//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;
    }
}

看完双亲委派机制的源码，再来回答一下上面的问题。
为什么要使用双亲委派机制？主要有两点：

1.沙箱安全机制：想想，如果我们自己写一个java.lang.String类，用自定义类加器去加载，此时应该加载jdk自带的String呢，还是应该加载我们自己的String类呢？没错，会加载jdk自己的java.lang.String，由引导类加载器直接加载之后返回，在运行时，调用我们自定义String时就会抛异常；沙箱安全机制就是为了防止我们去修改或重置jdk类库里面的一些核心类；

2.避免类的重复加载：这个比较好理解，当父加载器已经加载了该类时，就没有必要子ClassLoader再加载一次，保证被加载类的唯一性；

4.打破双亲委派机制

打破双亲委派机制？？？什么是打破双亲委派机制，该怎么做？？

打破双亲委派机制就是我们自定义类加载器，加载逻辑不按照jdk给我们指定的先由上层累加器先加载的逻辑；前面我们说过，自定义类加载器，继承ClassLoader，里面有两个核心方法，其中一个loadClass方法实现了双亲委派机制，想打破双亲委派机制，那就重写loadClass方法，实现自己的加载逻辑呗…

那自定义类加载器，打破双亲委派机制之后，可以加载自定义的java.lang.String吗？

想啥呢？要是这么就能修改和重置jdk类库的核心类，那沙箱安全机制还有个屁用，想要修改，也不是不可能，去改造hotspot源码…哈哈，后半句当我没说！！

一直说沙箱安全机制，那我们就来看看沙箱安全机制部分源码：

自定义类加载器去加载我们自定义java.lang.String过程中，我们一路debug，发现最后会调用到preDefineClass方法，会抛出沙箱安全异常，也就是说，非引导类加器是无法加载Jdk核心类库里面的类的！！！

想想我们的Tomcat，一个容器可以部署多个实例，甚至不同版本的实例，如果按照双亲委派机制加载，那不同版本实例中相同权限名称的类就只会被加载一次，就造成了多个实例或者版本共享，这样不就出问题了吗？Tomcat就是使用打破双亲委派机制实现多个类加载器去加载不同class包。

好了，今天我们JVM类加载相关的东西就分享到这里啦…