JVM类加载机制

EileenChang

于 2021-04-27 16:35:53 发布

阅读量275

点赞数 3

分类专栏： JVM 文章标签： jvm java

本文链接：https://blog.csdn.net/qq_24358759/article/details/116169904

版权

JVM 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章目录

1 类的生命周期
2 Loading
3 Linking
4 Initializing

1 类的生命周期

一个Class的生命周期可以分为Loading、Linking、Initializing、Using和Unloading五个阶段。在本篇内容中，我们主要关注的是Loading、Linking和Initializing三个阶段。
在这里插入图片描述

2 Loading

在加载(Loading)阶段，类加载器会根据类的全限定名将字节码文件从硬盘加载到内存中(Hotspot中为方法区)。将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构，并生成一个代表这个类的java.lang.Class对象，作为方法区中这个类的各种数据的访问入口。

2.1 ClassLoader

在这里插入图片描述

如图所示，JVM一共有四种类加载器：Bootstrap类加载器、Extension类加载器、Application类加载器和Custom类加载器。需要注意的是，它们之间并非继承关系，只是在语义上，顶层类加载器为底层类加载器的父加载器。Bootstrap类加载器是JVM中最顶层的类加载器，由C++实现，其他三种类加载器是ClassLoader的子类。不同的类加载器，会加载不同的类。Bootstrap类加载器加载的是jre/lib/rt.jar中所有的类。Extension扩展类加载器，加载Java平台中一些扩展功能的jar包，包括jre/lib/ext/*.jar，也可以通过参数-Djava.ext.dirs指定。Application类加载器会从classpath加载我们定义的类。Custom类加载器，是应用程序根据自身需要定义的ClassLoader。

2.2 双亲委派机制

JVM利用双亲委派机制进行类的加载，所谓的双亲委派，是先让父加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类。通俗的讲，就是某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父加载器，依次递归，如果父加载器可以完成类加载任务，就成功返回；只有父加载器无法完成此加载任务时，才自己去加载。
双亲委派机制避免了一个类的重复加载，保证每个类只会被加载一次。此外，更重要的是双亲委派机制保证了JVM的安全，使得Java平台提供的核心类不会被篡改。试想如果我们自定义了一个java.lang.String类，然后对其加载。如果自定义ClassLoader直接加载该类，而不是通过双亲委派机制，就可能将一个不安全的String类加载到内存中。

2.3 ClassLoader源码解析

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
{
    synchronized (getClassLoadingLock(name)) {
        // First, check if the class has already been loaded
        // 检查Class是否已经被加载过
        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.
                // 如果父加载器加载Class失败，则调用findClass方法进行加载
                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();
            }
        }
        // 对Class进行解析
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

ClassLoad.loadClass方法可以总结为三个步骤：先调用findLoadedClass方法检查类是否已经被加载，如果尚未加载则调用parent.loadClass方法进行加载，如果父加载器加载失败则调用findClass亲自加载。

2.4 自定义ClassLoader

我们还可以通过继承ClassLoader并重写findClass方法来自定义类加载器。

public class MyClassLoader extends ClassLoader {

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        File f = new File("E:/jvmtest/", name.replace(".", "/").concat(".class"));
        try (FileInputStream fis = new FileInputStream(f);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()){
            int b;
            while ((b=fis.read()) !=0) {
                baos.write(b);
            }
            byte[] bytes = baos.toByteArray();
            // 将字节数组转换成Class对象
            return defineClass(name, bytes, 0, bytes.length);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return super.findClass(name); //throws ClassNotFoundException
    }

    public static void main(String[] args) throws Exception {
        ClassLoader classloader = new MyClassLoader();
        Class clazz = classloader.loadClass("cn.flying.jvm.Test");

        Test test = (Test)clazz.newInstance();
        test.sayHello();
    }
}