class加载过程中的第一个阶段——加载(Loading)

对于JVM而言，拿来运行的就是class格式的字节码，例如X.class文件。

在JVM中，把一个符合JVM规范的class字节码加载到内存中，最终转换成能被Java程序所使用的情况，这整个过程

称之为类加载的过程。

类的生命周期

一个class字节码被加载到JVM内存，到卸载出JVM内存为止，会经历以下的几个阶段。

class-full-lifecircle

包括：加载(Loading)、验证(Verification)、准备(Preparation)、解析(Resolution)、初始化(Initialization)、使用(Using)、卸载(Unloading)。

其中类加载过程包括前五个阶段，而验证(Verification)、准备(Preparation)、解析(Resolution)三个阶段被统称为Linking阶段。

这个图中所指的执行顺序，只表示每个阶段开始的执行顺序，因为他们之间不是完全串行的方式运行。

本文只说明Loading的过程。

Loading过程

class的Loading过程分为以下三个步骤

1 通过一个类的完全限定名来找到此类的class格式的二进制字节流

2 将这个字节流数据转换为JVM中方法区的运行时数据

3 在堆内存中生成一个代表这个字节流的java.lang.Class类的对象，作为Java程序访问方法区中的字节流数据的接口。

使用Java代码来直接理解Loading过程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


package com.example;

import sun.misc.Launcher;

public class T {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> aClass = Launcher.getLauncher().getClassLoader().loadClass("com.example.T");
        System.out.println(aClass);
    }
}

上述代码中有两个重要的成分，ClassLoader对象（getClassLoader方法获取的）和loadClass方法（ClassLoader对象的方法），这两个部分是完成Loading过程的核心成分。

ClassLoader

ClassLoader对象是专门用来完成class字节码加载操作的对象，在JVM的规范中只定义了两种ClassLoader，一种是C++实现的BootstrapClassLoader，另一种则是其它的ClassLoader（Java语言实现的）。

而在Java 8之前（包括8），对于Java的使用者来说，有四类ClassLoader，如下图所示：

classloader-types

Bootstrap ClassLoader类是由C++实现，所以Java中没有与之对应的类（即，在Java SE源码中搜索不到BootClassLoader的类，所以在Java中获得该ClassLoader对象是会返回null）。

而ExtClassLoader和AppClassLoader是sun.misc.Launcher类中的内部类，这些都是Java SE自带的ClassLoader。

还有一种是可以让用户自定义的ClassLoader类。

它们之间的关系是上下层的关系，顺序按从下至上排序如下。

classloader-levels

User-define ClassLoader -> App ClassLoader -> Ext ClassLoader -> Bootstrap ClassLoader

loadClass

ClassLoader对象中loadClass方法是用来完成整个Loading过程的。所以要搞清楚Loading过程，就是要搞清楚loadClass方法中做了什么。

通过IDE工具，点击上述代码中的loadClass方法，直接跳转到java.lang.ClassLoader类中，可以找到具体的

loadClass方法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


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

该方法的大体流程如下：

当前类加载器首先查看自己是否已经加载过，检查自己的缓存，没找到的情况下会去调用其父类加载器，父类加载器也是同样的操作流程。

直到最顶层的Bootstrap ClassLoader，依然没有在其缓存中找到。

就会从上至下进行实际的加载操作，即上述代码中的findClass方法。

父类加载器会在自己的搜索范围内进行搜索，搜索到则返回结果。没搜索到则让子类加载器去搜索。直到最底层的类加载器，如果还没搜索到，则会抛出ClassNotFound的异常。

该方法的执行机制也称之为双亲委派机制，是Java默认的Loading策略。

findClass

loadClass方法使用了模板方法模式，将整个类加载机制的流程统一，具体如何找到class字节码的位置，以及如何生成与之对应的java.lang.Class对象都是在findClass方法中实现。

以AppClassLoader的findClass为目标，可以找到其父类URLClassLoader的findClass实现，代码如下

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


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);  // 基于class文件的路径，获取class字节流对象
                        if (res != null) {
                            try {
                                return defineClass(name, res);   // 根据完全限定名以及对应的class字节流对象生成Class对象
                            } 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;
    }

以上代码的流程很清晰。

1 将完全限定名转换成路径名，并通过该路径查找到对应的class文件，生成class字节流对象。

2 基于完全限定名和class字节流对象生成对应的java.lang.Class对象。

以上便是整个Loading过程的具体细节。

总览图

参考资料

《深入理解Java虚拟机第三版》
《jvms8》

文章目录

类的生命周期

Loading过程

ClassLoader

loadClass

findClass

总览图