类加载运行全过程

当我们使用Java命令运行某个类时，会先通过类加载器加载类文件到jvm。大致流程如下：

① 创建引导类加载器

② C++创建JVM启动器，实例化一个Launcher对象（单例）

③ Launcher对象效用getLauncher方法创建其他的类加载器,先实例化获取一个ExtClassLoader（扩展类加载器）、再获取AppClassLoader。

JVM默认使用Launcher的getClassLoader()方法返回的类加载器AppClassLoader的实例，调用AppClassLoader的loadClass方法加载我们的应用程序。

实例化的Launcher源码如下：

首先通过C++创建JVM启动器，并加载Launcher，在加载Launcher时，会首先初始化静态的对象 private static Launcher launcher = new Launcher();

//初始化Launcher对象
public Launcher() {
    Launcher.ExtClassLoader var1;
    try {
        var1 = Launcher.ExtClassLoader.getExtClassLoader();//初始化扩展类加载器ExtClassLoader
    } catch (IOException var10) {
        throw new InternalError("Could not create extension class loader", var10);
    }
		//初始化应用程序加载器AppClassLoader，并设置其父加载器为ExtClassLoader
    try {
        this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
    } catch (IOException var9) {
        throw new InternalError("Could not create application class loader", var9);
    }
		//设置当前线程的类加载器为应用程序加载器AppClassLoader
    Thread.currentThread().setContextClassLoader(this.loader);
    String var2 = System.getProperty("java.security.manager");
    if (var2 != null) {
        SecurityManager var3 = null;
        if (!"".equals(var2) && !"default".equals(var2)) {
            try {
                var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();
            } catch (IllegalAccessException var5) {
            } catch (InstantiationException var6) {
            } catch (ClassNotFoundException var7) {
            } catch (ClassCastException var8) {
            }
        } else {
            var3 = new SecurityManager();
        }
        if (var3 == null) {
            throw new InternalError("Could not create SecurityManager: " + var2);
        }
        System.setSecurityManager(var3);
    }

}

//调用AppClassLoader的loadClass方法加载我们的应用程序,最终会调用ClassLoader的loadClass
//这一步其实就是类加载器和双亲委派机制，参考本篇文章下面章节的描述
protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // 判断class是否被加载过
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        c = parent.loadClass(name, false);//找父 类加载器加载class，加载到则不为null
                    } else {
                        c = findBootstrapClassOrNull(name);//父类为null表示为引导类加载器，因为引导类加载器是C++创建的在java中就是null
                    }
                } catch (ClassNotFoundException e) {
                    
                }

                if (c == null) {
                    // 如果到引导类加载器仍没有加载到class，则再依次反转查找，
                   //即再由扩展类加载器ExtClassLoader加载，ExtClassLoader再加载不到就由应用程序加载器AppClassLoader加载，总会被加载到的
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);//自己写的类最后还是通过AppClassLoader的findClass找到（其实是父类的函数），AppClassLoader的父类是URLClassLoader
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

类加载器loadClass方法的类加载过程

步骤：加载 >> 验证 >> 准备 >> 解析 >> 初始化 >> 使用 >> 卸载

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

验证：校验字节码文件的正确性。

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

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

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

类加载器及双亲委派机制

Java里有如下几种类加载器：

引导类加载器：负责加载支撑JVM运行的位于JRE的lib目录下的核心类库，比如rt.jar、charsets.jar等

扩展类加载器：负责加载支撑JVM运行的位于JRE的lib目录下的ext扩展目录中的JAR类包。

应用程序类加载器：负责加载ClassPath路径下的类包，主要就是加载你自己写的那些类。

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

双亲委派机制：Java类先由父类加载器加载，不行再由子类加载器加载。

打破双亲委派机制方式：自定义类加载器(重写findClass方法)，并重写loadClass方法。

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

沙箱安全机制：自己写的java.lang.String.class类不会被加载，这样便可以防止核心API库被随意篡改。

避免类的重复加载：当父亲已经加载了该类时，就没有必要子ClassLoader再加载一次，保证被加载类的唯一性。

Tomcat自定义加载器就是打破双亲委派机制，自定义类加载器。

备注

本文部分文案来自于图灵课堂讲义。