jvm-类加载机制分析

类加载流程

我们创建一个类，当点击main方法运行时实际流程如下：

image.png

其中引导类加载器属于c++语言的hotspot实现，其他类加载器由java实现。

loadclass步骤

类加载器最重要的步骤就是loadClass的步骤，具体流程如下：

image.png

1. 验证
   java类编译成class文件，是有一定规律存在的，例如固定的开头（cafe babe），验证即判断字节码文件的是否符合标准规律。
2. 准备
   给静态变量分配内存并附默认值，例如static int i = 1; 类加载时先给i变量分配内存，并让i=0.
3. 解析
   将符号引用替换为直接引用，把一些静态变量和静态方法，替换成指向内存的指针或句柄。由于jvm的懒加载机制，动态连接是在程序运行期间完成的将符号引用替换成直接引用。
4. 初始化
   对类的静态变量初始化为指定的值，执行静态代码块。

加载器示例

publicclassTestJDKClassLoader{  

public static void main(String[] args) {

System.out.println(String.class.getClassLoader());
System.out.println(com.sun.crypto.provider.DESKeyFactory.class.getClassLoader().getClass().getName());
System.out.println(TestJDKClassLoader.class.getClassLoader().getClass().getN ame());
System.out.println();

ClassLoader appClassLoader = ClassLoader.getSystemClassLoader();
ClassLoader extClassloader = appClassLoader.getParent();
ClassLoader bootstrapLoader = extClassloader.getParent();
System.out.println("the bootstrapLoader : " + bootstrapLoader);
System.out.println("the extClassloader : " + extClassloader);
System.out.println("the appClassLoader : " + appClassLoader);
System.out.println(); 

System.out.println("bootstrapLoader加载以下文件:"); 
URL[] urls = Launcher.getBootstrapClassPath().getURLs(); 
for (int i = 0; i < urls.length; i++) { 
System.out.println(urls[i]);
}
System.out.println(); 

System.out.println("extClassloader加载以下文件:"); System.out.println(System.getProperty("java.ext.dirs"));
System.out.println(); 
System.out.println("appClassLoader加载以下文件:"); System.out.println(System.getProperty("java.class.path"));
} 
}

运行结果：

null
sun.misc.LauncherAppClassLoader
thebootstrapLoader:null theextClassloader:sun.misc.LauncherAppClassLoader@14dad5dc
bootstrapLoader加载以下文件: file:/D:/dev/Java/jdk1.8.0_45/jre/lib/resources.jar file:/D:/dev/Java/jdk1.8.0_45/jre/lib/rt.jar file:/D:/dev/Java/jdk1.8.0_45/jre/lib/sunrsasign.jar file:/D:/dev/Java/jdk1.8.0_45/jre/lib/jsse.jar file:/D:/dev/Java/jdk1.8.0_45/jre/lib/jce.jar file:/D:/dev/Java/jdk1.8.0_45/jre/lib/charsets.jar file:/D:/dev/Java/jdk1.8.0_45/jre/lib/jfr.jar file:/D:/dev/Java/jdk1.8.0_45/jre/classes
extClassloader加载以下文件:
D:\dev\Java\jdk1.8.0_45\jre\lib\ext;C:\Windows\Sun\Java\lib\ext
appClassloader 会加载所有文件，太多就不打印出来了

双亲委派

jvm的类加载机制采取双亲委派机制，从应用程序类加载器、扩展程序加载类、引导类加载器，从下往上依次判断是否加载过，如加载过则直接返回，未加载过则委托父加载器在自己的路径中进行加载，如果父加载器在加载路径中未找到该类，在回复子加载器自己加载，以此类推。
比如我们的Math类，最先会找应用程序类加载器加载，应用程序类加载器会先委托扩展类加载器加载，扩展类加载器再委托引导类加载器，顶层引导类加载器在自己的类加载路径里找了半天 没找到Math类，则向下退回加载Math类的请求，扩展类加载器收到回复就自己加载，在自己的 类加载路径里找了半天也没找到Math类，又向下退回Math类的加载请求给应用程序类加载器， 应用程序类加载器于是在自己的类加载路径里找Math类，结果找到了就自己加载了。。
双亲委派机制说简单点就是，先找父亲加载，不行再由儿子自己加载

jvm双亲委派源码

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();
                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();
                    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;
        }
    }

findLoadedClass方法主要作用是查找是否加载过该类，加载过则直接返回了，查看是否有父加载器（注意不是父类），有则委托父加载器加载，直到最顶层则直接通过路径查找是否可以加载类，不可以加载测让子加载依次加载，直到加载到为止。其中findBootstrapClassOrNull方法代表到最顶层，通过native方法获取引导类加载器加载，findClass方法是一个钩子方法，代表运行到哪个类，则执行哪个类的findClass方法，一般加载器的findClass方法最终都会调用到URLClassLoader类中的此方法，URLClassLoader是大部分加载器的父类用于存放类加载器的各路径。

为什么设计双亲委派机制

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

packagejava.lang;


publicclassString{

public static void main(String[] args) { 
System.out.println("**************My String Class**************");
}


运行结果:
错误: 在类 java.lang.String 中找不到 main 方法, 请将 main 方法定义为: public static void main(String[] args)
否则 JavaFX 应用程序类必须扩展javafx.application.Application

解析：由于双亲委派机制，String类和核心包的String同名，引导加载器在核心包中就会加载核心包中的String类，该类没有main 方法，所以报错。

全盘负责委托机制

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

自定义加载类，并打破双亲委派机制

/**
 * @author Turbo
 * @date 2022/6/14.
 */
public class MyClassloadTest {
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);
            return defineClass(name, data, 0, data.length);
        } catch (Exception e) {
            e.printStackTrace();
            throw new ClassNotFoundException();
        }
    }

    /**
     * 方法loadClass功能描述:TODO  覆写loadClass方法，
     * 打破双亲委派机制，否则调用父类方法则正常采用双亲委派机制
     *
     * @param
     * @return
     * @throws
     * @Author Turbo
     * @date 2022/6/14 2:05 PM
     */
    protected Class loadClass(String name, boolean resolve)
            throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {
            Class c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                long t1 = System.nanoTime();
                //自己的类则采用自己的类加载器，其他类采用jvm默认加载
                if("com.demo.Lambda".equals(name)){
                    c = findClass(name);
                }else{
                    c = super.loadClass(name);
                }

                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }
}


    public static void main(String[] args) throws Exception {
        MyClassLoader classLoader = new MyClassLoader("/demo/target");
        Class clazz = classLoader.loadClass("com.demo.Lambda");
        Object obj = clazz.newInstance();
        Method method = clazz.getDeclaredMethod("supplier",null);
        method.invoke(obj, null);
        System.out.println(clazz.getClassLoader().getClass().getName());
    }
}