类加载机制与类加载器ClassLoader

类加载机制与类加载器

当我们的Java代码在调用某个类时，我们的程序是如何识别这个类的呢？这就要提到我们的类加载。

当程序主动去使用某个类时，我们把这个类的信息载入进来这一行为称为类加载

类加载的过程

类的加载过程大致分为加载，链接，初始化三个阶段，链接阶段又分为：验证、准备、解析。

一个java文件从被加载到被卸载这个生命过程，总共要经历5个阶段，JVM将类加载过程分为： （加链初使卸）
　　加载->链接（验证+准备+解析）->初始化（使用前的准备）->使用->卸载

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7fdv8gip-1627468329154)(C:\Users\26605\Desktop\无标题.png)]

1. 加载： 加载指的是将类的class文件读入到内存，并为之创建一个java.lang.Class对象，也就是说，当程序中使用任何类时，系统都会为之建立一个java.lang.Class对象。

   类的加载由类加载器完成，类加载器通常由JVM提供，这些类加载器也是前面所有程序运行的基础，JVM提供的这些类加载器通常被称为系统类加载器。除此之外，开发者可以通过继承ClassLoader基类来创建自己的类加载器。

   通过使用不同的类加载器，可以从不同来源加载类的二进制数据，通常有如下几种来源。

• 从本地文件系统加载class文件，这是前面绝大部分示例程序的类加载方式。

• 从JAR包加载class文件，这种方式也是很常见的，前面介绍JDBC编程时用到的数据库驱动类就放在JAR文件中，JVM可以从JAR文件中直接加载该class文件。

• 通过网络加载class文件。

• 把一个Java源文件动态编译，并执行加载。

  类加载器通常无须等到“首次使用”该类时才加载该类，Java虚拟机规范允许系统预先加载某些类。

  类加载器分为以下四种：

2. 链接
   当类被加载之后，系统为之生成一个对应的Class对象，接着将会进入连接阶段，连接阶段负责把类的二进制数据合并到JRE中。类连接又可分为如下3个阶段。

   1)验证：验证阶段用于检验被加载的类是否有正确的内部结构，并和其他类协调一致。Java是相对C++语言是安全的语言，例如它有C++不具有的数组越界的检查。这本身就是对自身安全的一种保护。验证阶段是Java非常重要的一个阶段，它会直接的保证应用是否会被恶意入侵的一道重要的防线，越是严谨的验证机制越安全。验证的目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求，不会危害虚拟机自身安全。其主要包括四种验证，文件格式验证，元数据验证，字节码验证，符号引用验证。

   2)准备：类准备阶段负责为类的静态变量分配内存，并设置默认初始值。

   3)解析：将类的二进制数据中的符号引用替换成直接引用。说明一下：符号引用：符号引用是以一组符号来描述所引用的目标，符号可以是任何的字面形式的字面量，只要不会出现冲突能够定位到就行。布局和内存无关。直接引用：是指向目标的指针，偏移量或者能够直接定位的句柄。该引用是和内存中的布局有关的，并且一定加载进来的。

3. 类的初始化

   初始化是为类的静态变量赋予正确的初始值，准备阶段和初始化阶段看似有点矛盾，其实是不矛盾的，如果类中有语句：private static int a = 10，它的执行过程是这样的，首先字节码文件被加载到内存后，先进行链接的验证这一步骤，验证通过后准备阶段，给a分配内存，因为变量a是static的，所以此时a等于int类型的默认初始值0，即a=0,然后到解析（后面在说），到初始化这一步骤时，才把a的真正的值10赋给a,此时a=10。

   （1）类的加载时机:

   1）创建类的实例，也就是new一个对象
   　　2）访问某个类或接口的静态变量，或者对该静态变量赋值
   　　3）调用类的静态方法
   　　4）反射（Class.forName(“com.cyq.load”)）
   　　5）初始化一个类的子类（会首先初始化子类的父类）
   　　6）JVM启动时标明的启动类，即文件名和类名相同的那个类

   forName和loaderClass区别

   • Class.forName()得到的class是已经初始化完成的。
   • Classloader.loaderClass得到的class是还没有链接（验证，准备，解析三个过程被称为链接）的。

   （2）类的初始化顺序
   　　1）如果这个类还没有被加载和链接，那先进行加载和链接
   　　2）假如这个类存在直接父类，并且这个类还没有被初始化（注意：在一个类加载器中，类只能初始化一次），那就初始化直接的父类（不适用于接口）
   　　3）加入类中存在初始化语句（如static变量和static块），那就依次执行这些初始化语句。

4. 4）总的来说，初始化顺序依次是：（静态变量、静态初始化块）–>（变量、初始化块）–> 构造器；

如果有父类，则顺序是：父类static方法 –> 子类static方法 –> 父类构造方法- -> 子类构造方法

类加载器

类加载器分为以下四种：

1）BootstrapClassLoader（启动类加载器）
　　负责加载$JAVA_HOME中jre/lib/rt.jar里所有的class，加载System.getProperty(“sun.boot.class.path”)所指定的路径或jar。
2）ExtensionClassLoader（标准扩展类加载器）
　　负责加载java平台中扩展功能的一些jar包，包括$JAVA_HOME中jre/lib/*.jar或-Djava.ext.dirs指定目录下的jar包。载System.getProperty(“java.ext.dirs”)所指定的路径或jar。
3）AppClassLoader（系统类加载器）
　　负责记载classpath中指定的jar包及目录中class
4）CustomClassLoader（自定义加载器）
　　属于应用程序根据自身需要自定义的ClassLoader，如tomcat、jboss都会根据j2ee规范自行实现。

类加载机制

• 全盘负责：所谓全盘负责，就是当一个类加载器负责加载某个Class时，该Class所依赖和引用其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入。

• 双亲委派：所谓的双亲委派，则是先让父类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类。通俗的讲，就是某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父加载器，依次递归，如果父加载器可以完成类加载任务，就成功返回；只有父加载器无法完成此加载任务时，才自己去加载。

• 缓存机制。缓存机制将会保证所有加载过的Class都会被缓存，当程序中需要使用某个Class时，类加载器先从缓存区中搜寻该Class，只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存入缓冲区中。这就是为很么修改了Class后，必须重新启动JVM，程序所做的修改才会生效的原因。

  接下来我们通过Classloader类源码来分析双亲委派机制

  //定义父类Classloader成员变量，意为父类加载器
  // The parent class loader for delegation
  // Note: VM hardcoded the offset of this field, thus all new fields
  // must be added *after* it.
  private final ClassLoader parent;
  //系统的加载器
  // The class loader for the system
  // @GuardedBy("ClassLoader.class")
  private static ClassLoader scl;
  

  在Classloader里有两个构造方法

  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;
      }
  }
  //
  protected ClassLoader() {
          this(checkCreateClassLoader(), getSystemClassLoader());
      }
  

可以看到有个private构造方法与protect构造方法，而private构造方法由protected构造方法调用，所以我们主要对第二个构造方法进行入手，第二个构造方法调用第一个构造方法时，传入了两个参数，checkCreateClassLoader()与getSystemClassLoader()，

public static ClassLoader getSystemClassLoader() {
    initSystemClassLoader();
    if (scl == null) {
        //scl就为系统的加载器标识
        return null;
    }
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkClassLoaderPermission(scl, Reflection.getCallerClass());
    }
    return scl;
}

在getSystemClassLoader方法有这么一段描述：返回委派的系统类加载器，这是新类加载器实例的默认委托父级，通常是用于启动应用程序的类加载器。此方法首先在运行时启动序列的早期调用，此时它创建系统类装入器并将其设置为调用线程的上下文类装入器。

在getSystemClassLoader方法里调用了initSystemClassLoader()

private static synchronized void initSystemClassLoader() {
    if (!sclSet) {
        if (scl != null)
            throw new IllegalStateException("recursive invocation");
        sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
        //sun.misc.Launcher类是java的入口，在启动java应用的时候会首先创建Launcher类，创建Launcher类的时候回准备应用程序运行中需要的类加载器。
        if (l != null) {
            Throwable oops = null;
            scl = l.getClassLoader();
            try {
                scl = AccessController.doPrivileged(
                    new SystemClassLoaderAction(scl));
                // 类java.security.AccessController提供了一个默认的安全策略执行机制，它使用栈检查来决定潜在不安全的操作是否被允许。这个访问控制器不能被实例化，它不是一个对象，而是集合在单个类中的多个静态方法。
            } catch (PrivilegedActionException pae) {
                oops = pae.getCause();
                if (oops instanceof InvocationTargetException) {
                    oops = oops.getCause();
                }
            }
            if (oops != null) {
                if (oops instanceof Error) {
                    throw (Error) oops;
                } else {
                    // wrap the exception
                    throw new Error(oops);
                }
            }
        }
        sclSet = true;
    }
}

分析到此，还不够深入，请参见一下这位博主

Java类默认加载器