JVM-类加载和双亲委派

JVM-类加载和双亲委派

---

---

前言

提示：当我们用java命令运行某个类的main函数启动程序时，首先需要通过类加载器把主类加载到JVM。

一、类加载过程？

其中loadClass的类加载过程如下：
加载 >> 验证 >> 准备 >> 解析 >> 初始化 >> 使用 >> 卸载

1.1 加载

在硬盘上查找并通过IO读入字节码文件，使用到类时才会加载，例如调用类的main()方法，new对象等等，在加载阶段会在内存中生成一个代表这个类的。java.lang.Class对象，作为方法区这个类的各种数据的访问入口。

1.2 验证

校验字节码文件的正确性

1.3 准备

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

1.4 解析

将符号引用替换为直接引用加粗样式，该阶段会把一些静态方法(符号引用，比如main()方法)替换为指向数据所存内存的指针或句柄等(直接引用)，这是所谓的静态链接过程(类加载期间完成)，动态链接是在程序运行期间完成的将符号引用替换为直接引用，下节课会讲到动态链接。

1.5 初始化

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

1.6加载那一步干了什么？

1. 通过全类名获取定义此类的二进制字节流。
2. 将此字节流所代表的静态结构转换成为方法区的运行时数据结构。
3. 在内存中生成一个代表该类的Class对象，作为方法区的运行时数据。
   
   类被加载到方法区中后主要包含 运行时常量池、类型信息、字段信息、方法信息、类加载器的引用、对应class实例的引用等信息。

1.7类加载器

java内置了三个非常重要的类加载器ClassLoader，除了BootstrapClassLoader其他类加载器均由java实现且全部继承java.lang.ClassLoader
4. BootstrapClassLoader(启动类加载器)：最顶层加载器，负责加载支撑JVM运行的位于JRE的lib目录下的核心类库，比如 rt.jar、charsets.jar等。
5. ExtensionClassLoader扩展类加载器**，负责加载支撑JVM运行的位于JRE的lib目录下的ext扩展目录中的JAR 类包**
6. AppClassLoader应用程序类加载器，负责加载ClassPath路径下的类包，主要就是加载你自己写的那 些类
7. 自定义加载器：负责加载用户自定义路径下的类包

二、双亲委派机制

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

从应用程序类加载器寻找加载直到启动类加载器，若找不到再返回自己的类加载器加载。意思就是先找自己的爹解决，不行就自己来。

2.1 类加载器初始化过程

1. sun.misc.Launcher初始化使用了单例模式设计，保证一个JVM虚拟机内只有一个 sun.misc.Launcher实例。
2. 在Launcher构造方法内部，其创建了两个类加载器，分别是 sun.misc.Launcher.**ExtClassLoader(**扩展类加载器)和sun.misc.Launcher.AppClassLoader(应 用类加载器)。
3. JVM默认使用Launcher的getClassLoader()方法返回的类加载器AppClassLoader的实例加载我们 的应用程序。

public Launcher() {
        Launcher.ExtClassLoader var1;
        try {
        //构造扩展类加载器，在构造的过程中将其父加载器设置为null,因为引导类加载器是C++实现的。
            var1 = Launcher.ExtClassLoader.getExtClassLoader();
        } catch (IOException var10) {
            throw new InternalError("Could not create extension class loader", var10);
        }
        try {
        //构造应用类加载器，在构造的过程中将其父加载器设置为ExtClassLoader，
        //Launcher的loader属性值是AppClassLoader，我们一般都是用这个类加载器来加载我们自 己写的应用程序
            this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
        } catch (IOException var9) {
            throw new InternalError("Could not create application class loader", var9);
        }
.....

AppClassLoader 的loadClass方法最终会调用其父类ClassLoader的loadClass方法

1 //ClassLoader的loadClass方法，里面实现了双亲委派机制
2 protected Class<?> loadClass(String name, boolean resolve)
3 throws ClassNotFoundException
4 {
5 synchronized (getClassLoadingLock(name)) {
6 // 检查当前类加载器是否已经加载了该类
7 Class<?> c = findLoadedClass(name);
8 if (c == null) {
9 long t0 = System.nanoTime();
10 try {
11 if (parent != null) { //如果当前加载器父加载器不为空则委托父加载器加载该类
12 c = parent.loadClass(name, false);
13 } else { //如果当前加载器父加载器为空则委托引导类加载器加载该类
14 c = findBootstrapClassOrNull(name);
15 }
16 } catch (ClassNotFoundException e) {
17 // ClassNotFoundException thrown if class not found
18 // from the non‐null parent class loader
19 }
20
21 if (c == null) {
22 // If still not found, then invoke findClass in order
23 // to find the class.
24 long t1 = System.nanoTime();
25 //都会调用URLClassLoader的findClass方法在加载器的类路径里查找并加载该类
26 c = findClass(name);
27
28 // this is the defining class loader; record the stats
29 sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 ‐ t0);
30 sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
31 sun.misc.PerfCounter.getFindClasses().increment();
32 }
33 }
34 if (resolve) { //不会执行
35 resolveClass(c);
36 }
37 return c;
38 }
39 }

读取class文件

protected Class<?> findClass(final String name)
        throws ClassNotFoundException
    {
        final Class<?> result;
        try {
            result = AccessController.doPrivileged(
                new PrivilegedExceptionAction<Class<?>>() {
                    public Class<?> run() throws ClassNotFoundException {
                        String path = name.replace('.', '/').concat(".class");
                        Resource res = ucp.getResource(path, false);
                        if (res != null) {
                            try {
                                return defineClass(name, res);
                            } catch (IOException e) {
                                throw new ClassNotFoundException(name, e);
                            } catch (ClassFormatError e2) {
                                if (res.getDataError() != null) {
                                    e2.addSuppressed(res.getDataError());
                                }
                                throw e2;
                            }
                        } else {
                            return null;
                        }
                    }
                }, acc);
        } catch (java.security.PrivilegedActionException pae) {
            throw (ClassNotFoundException) pae.getException();
        }
        if (result == null) {
            throw new ClassNotFoundException(name);
        }
        return result;
    }

为什么要双亲委派机制

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