关于java:深入理解JVM之ClassLoader

28次阅读

共计 5081 个字符，预计需要花费 13 分钟才能阅读完成。

1. 什么是类加载器

在编写 Java 程序时须要应用 javac 命令将.java 后缀名的文件编译成.class 文件，而后 JVM 通过执行.class 文件来运行咱们写的程序，那么 JVM 怎么能力执行.class 文件呢？
这就须要类加载器了。

2. 有哪几种类加载器

  • BootstrapClassLoader：这个类加载器能够被称为疏导类加载器，它由 C ++ 语言编写，在 JDK 中看到的是应用 native 标注的办法。它负责加载 jre/lib 下的外围包，例如：rt.jar。
  • ExtClassLoader：它被称为扩大类加载器，它是由 Java 语言编写，用于加载 jre/lib/ext 目录中的包。
  • AppClassLoader：这个类加载器叫做应用程序类加载器，它是咱们平时应用最频繁的一品种加载器，用于加载 classpath 下的.class 文件，也就是咱们本人写的程序。
  • 自定义的类加载器：该类加载器用于加载咱们指定的一些类。

3.ClassLoader 之间的关系

3.1 类加载器创立过程

在 jdk 中找到 sun.misc.Launcher 文件，这个文件是 JVM 中的启动器实例，在该类外部有 getLauncher() 办法

public static Launcher getLauncher() {return launcher;}

它返回的是launcher 实例

private static Launcher launcher = new Launcher();

在构造方法调用时会初始化 ExtClassLoader 和 AppClassLoader（BootstrapClassLoader 会在 Java 虚拟机创立之后进行加载，所以是在此之前）。

public Launcher() {
    Launcher.ExtClassLoader var1;
    try {var1 = Launcher.ExtClassLoader.getExtClassLoader();
    } catch (IOException var10) {throw new InternalError("Could not create extension class loader", var10);
    }

    try {this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
    } catch (IOException var9) {throw new InternalError("Could not create application class loader", var9);
    }

    Thread.currentThread().setContextClassLoader(this.loader);
    // 非核心的就去掉了

}

通过点击 getXxxClassLoader() 跟到最初能够看到

private ClassLoader(Void unused, ClassLoader parent) {
    // 通过这行能够让加载器之间建设父子级关系
    this.parent = parent;
    if (ParallelLoaders.isRegistered(this.getClass())) {parallelLockMap = new ConcurrentHashMap<>();
        package2certs = new ConcurrentHashMap<>();
        assertionLock = new Object();} else {
        // no finer-grained lock; lock on the classloader instance
        parallelLockMap = null;
        package2certs = new Hashtable<>();
        assertionLock = this;
    }
}

留神： 咱们查看 ExtClassLoader 时会发现这里的 parent 是 null，而查看 AppClassLoader 时传入的 parent 是 ExtClassLoader 的对象实例。所以这里也就印证了下面画的图。

3.2 探索加载类的流程

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 {
                    // 如果父加载器不存在就是用 BootstrapClassLoader 加载
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }
            
            // 如果父加载器和 BootstrapClassLoader 都没有加载到的话
            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);
        }
        // 返回已加载到的类或 null
        return c;
    }
}

加载步骤：

  • 判断以后类加载器是否曾经加载指标类，如果曾经加载则返回，否则应用判断是否存在父加载器
  • 如果父加载器存在反复步骤 1，直到parent == null，这时会应用 BootstrapClassLoader 加载
  • 如果父加载器和疏导类加载器都没有加载到指标类的话，就应用本人的findClass() 办法来加载指标类。

找到某个 ClassLoader，这里以 AppClassLoader 为例

static class AppClassLoader extends URLClassLoader {

在 AppClassLoader 中搜寻 findClass() 办法是找不到的，所以找到每个加载器独特的父类 URLClassLoader，在这里能够看到findClass() 办法。

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);
                        }
                    } else {return null;}
                }
            }, acc);
    } catch (java.security.PrivilegedActionException pae) {throw (ClassNotFoundException) pae.getException();}
    if (result == null) {throw new ClassNotFoundException(name);
    }
    return result;
}

findClass办法的作用是从指定的门路找到传入的文件名称的.class 文件，并返回回去，该办法的次要逻辑在 run() 办法中。

4. 实现本人的 ClassLoader

从后面能够晓得，要想实现 classLoader 只须要继承 ClassLoader 类并重写 findClass 和 loadClass 办法即可。

4.1 创立 java 文件

在桌面创立了一个名为 Test 的 Java 文件，并应用 javac 命令进行编译。

public class Test {public void sayHi() {System.out.println("hi!");
    }
    
    public static void main(String[] args) {System.out.println("Hello World!");
    }
}

4.2 实现办法重写与测试

/**
 * Created by luyi on 2021/2/16.
 * 形容：自定义 ClassLoader
 */
public class MyClassLoader extends ClassLoader {

    public String classPath;

    public MyClassLoader(String classPath) {this.classPath = classPath;}

    /**
     * 通过输出流读取文件
     *
     * @param name 文件全限定类名
     */
    public byte[] loadByte(String name) throws IOException {if (name == null || name.length() == 0) {return new byte[1024];
        }

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

    /**
     * 将指定的门路中的指定的文件进行加载
     *
     * @param name 全限定类名
     * @return
     * @throws ClassNotFoundException
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {if (name == null || name.length() == 0) {return null;}

        try {byte[] data = loadByte(name);
            return defineClass(name, data, 0, data.length);
        } catch (IOException e) {e.printStackTrace();
            throw new ClassNotFoundException();}
    }

    public static void main(String[] args) throws Exception {MyClassLoader loader = new MyClassLoader("/Users/luyi/Desktop");
        Class<?> clazz = loader.loadClass("Test", false);
        Object instance = clazz.newInstance();
        Method sayHi = clazz.getDeclaredMethod("sayHi", null);
        sayHi.invoke(instance, null);

        System.out.println(clazz.getClassLoader().getClass().getName());
    }
}

运行后果：

从运行后果能够看出，自定义的类加载器曾经实现了对指定文件的加载，并正确的执行了办法。

正文完
java
发表至： java
2021-02-16
 0
Spring-Cloud-Config-学习二
死磕-java集合之ConcurrentSkipListMap源码分析
关于java:JVM性能优化服务发生OOM故障定位方案
浅析微服务框架 Helidon 的使用