1、JVM类的加载子系统

灰太狼 2023-01-16 06:49 118阅读 0赞

### 文章目录 ###

*  1、加载
 *   *  1.1 获取加载器方式
     *  1.2 双亲委派机制
     *  1.3 加载class对象相同条件
 *  2、链接
 *   *  2.1 验证
     *  2.2 准备
     *  2.3 解析
 *  3、初始化

如下图所示，JVM类的加载系统负责从文件系统、网络中或者压缩包中加载Class字节码文件。整个类加载子系统主要由三大步骤完成：加载 -> 链接 -> 初始化。经过类加载系统加载后，Class文件被加载到内存中并对类进行初始化（注意只是初始化了类的静态变量或者静态代码块，并不是执行对象的初始化方法，可以参考后续介绍）。  
![在这里插入图片描述][20210424180459668.PNG_pic_center]

# 1、加载 #

类加载子系统的加载阶段主要由三类加载器进行加载Class文件：引导类加载器、扩展类加载器、系统类加载器。  
加载器ClassLoader只负责加载Class字节码文件，具体字节码是否可以运行由后续的执行器来决定。加载的类信息存放在方法区的内存空间中，JDK中改为元数据空间中。方法区中还会存放运行时常量池信息，包括字符串、数字常量。  
加载是通过类的全限定名获取类的二进制字节流，通过字节流将字节码文件加载到方法区的运行时数据结构中存储，并在内存中生成该类的Class对象，作为方法区该类的各种数据的访问入口。

加载器分为如下4类加载器

1.  Bootstrap ClassLoader  
    引导类加载器，也叫启动类加载器，由C/C++语言实现。主要加载java的核心类库，加载的路径包括 JAVA\_HOME/jre/lib/rt.jar、resource.jar或sun.boot.class.path路径下的类。启动类加载器没有父加载器，不继承ClassLoader，启动类加载器会加载扩展类加载器和应用程序类加载器，并且启动类加载器会指定为扩展类加载器和应用程序类加载器的父加载器。出于安全考虑，BootStrap加载器只能加载包名为java、javax、sun等开头的类。
2.  扩展类加载器  
    扩展类加载器继承自ClassLoader类，父类加载器为启动类加载器。扩展类加载器加载jre/lib/ext目录下的类库，或者java.ext.dirs系统属性指定的目录中加载类库，如果用户床架的jar放在此目录下，该jar也会由扩展类加载器加载。
3.  应用程序类加载器  
    应用程序类加载器继承自ClassLoader类，父加载器为启动类加载器，负责加载环境变量classpath或系统属性java.class.path指定路径下的类库。该加载器为程序中默认的加载器，一般java应用均由该加载器加载完成。通过ClassLoader.getSystemClassLoader()可以得到程序应用类加载器。
4.  用户自动以加载器  
    可以自动以加载器，从指定位置加载类，比如从硬盘指定位置或者网络。

## 1.1 获取加载器方式 ##

*  获取指定加载器

/*获取指定类的ClassLoader*/
    public static void testClassLoader1(){ 
        ClassLoader classLoader = Integer.class.getClassLoader();           //BootStrap Loader
        System.out.println("classLoader : " + classLoader);
        ClassLoader classLoader1 = HostUtils.class.getClassLoader();        //Extension ClassLoader
        System.out.println("classLoader1 : " + classLoader1);
        ClassLoader classLoader2 = ClassLoaderDemo.class.getClassLoader();  //Appliction ClassLoader
        System.out.println("classLoader2 : " + classLoader2);
    }

输出结果如下：

classLoader : null
    classLoader1 : sun.misc.Launcher$ExtClassLoader@14ae5a5
    classLoader2 : sun.misc.Launcher$AppClassLoader@58644d46

Integer由启动类加载器加载器加载，启动类加载器为null，不可以获取；  
HostUtils由扩展类加载器加载；  
ClassLoaderDemo由应用加载器加载。

*  获取当前上下文的加载器

public static void testClassLoader2(){ 
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        System.out.println("classloader : " + classLoader);
    }

输出结果如下，说明程序的上下文加载器为Application ClassLoader

classloader : sun.misc.Launcher$AppClassLoader@58644d46

*  获取父加载器

public static void testClassLoader3(){ 
        ClassLoader appClassLoader = Thread.currentThread().getContextClassLoader();
        System.out.println("appClassLoader : " + appClassLoader);               //当前线程加载器为Application ClassLoader
        ClassLoader extensionClassLoader = appClassLoader.getParent();
        System.out.println("extensionClassLoader : " + extensionClassLoader);   //Application ClassLoader的父加载器为Extension ClassLoader
        ClassLoader bootStrapClassLoader = extensionClassLoader.getParent();    
        System.out.println("bootStrapClassLoader : " + bootStrapClassLoader);   //Extension ClassLoader的父加载器为BootStrap ClassLoader
    }

输出结果如下：

appClassLoader : sun.misc.Launcher$AppClassLoader@58644d46
    extensionClassLoader : sun.misc.Launcher$ExtClassLoader@74a14482
    bootStrapClassLoader : null

*  获取系统加载器

public static void testClassLoader4(){ 
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println("systemClassLoader : " + systemClassLoader);	//系统加载器为Applciation ClassLoader
    }

## 1.2 双亲委派机制 ##

java虚拟机加载class字节码文件时采用的按需加载方式，只有当使用时才会把Class文件加载到内存中，而加载Class文件时采用的就是双亲委派机制，把要加载Class的任务交由父加载器加载。

**双亲委派机制原理**：如果一个类加载器收到了类加载的请求，该类加载器并不会立即去加载，而是把加载任务先委托给父加载器加载；如果父加载器还有父加载器，则会继续向上委托，一直委托到启动类加载器；如果父加载器可以完成加载Class字节码的任务，就成功加载返回，若需要加载的类不在父加载器加载范围内，子加载器尝试去加载，一直到向下委托到可以加载的加载器。

案例一，比如在自己的工程内新建一个java.lang.Integer类，当用到Integer时，其实并没加载自己工程内的java.lang.Integer，而是加载了rt.jar包下的java.lang.Integer类。当在代码中用到Integer类时，Application ClassLoader会把加载java.lang.Integer的任务向上委托给Extension ClassLoader加载器，Extension ClassLoader加载器又会继续把加载java.lang.Integer的任务继续向上委托给Bootstrap ClassLoader进行加载，恰巧，java.lang.Integer在Bootstrap ClassLoader的加载范围内，因此BootStrap ClassLoader会把rt.jar包下的Integer加载到内存中，而不是由Application ClassLoader把工程中新建的Integer加载到内存中。  
案例二，比如在程序中实现了java.lang.Runnable接口，那么该实现类会由Application ClassLoader加载，而接口Runnable会由Bootstrap ClassLoader加载。  
案例三，比如在工程中新建java.lang包，然后在该包下随意建一个类，Application ClassLoader会一直向上委托，知道委托到Bootstrap ClassLoader加载器，Bootstrap ClassLoader一检查包名为java.lang，属于自己的加载范围，但是当Bootstrap ClassLoader进行加载时，虚拟机就会包出安全问题，禁止加载自定义包名为java.lang的类。

案例一、案例二、案例三都遵循了沙箱安全机制，类加载时首先加载java的核心源代码，避免硬盘、网络等其他位置传过来一个与java核心类的包名以及类名相同的类被首先加载，保证了对java核心源代码的保护，这就是**沙箱安全机制**。

双亲委派机制优势：

*  避免重复加载类；
 *  保护程序安全，防止核心API被串改。

## 1.3 加载class对象相同条件 ##

类加载器把class字节码文件加载到内存中生成Class对象，JVM中表示两个Class对象是否为同一个类存在的两个必要条件：

1.  类包名必须一致以及类的名字一致；
2.  加载这个类的ClassLoader必须相同，在JVM中即使两个Class对象来源同一个Class字节码文件，被同一个虚拟机加载，只要加载他们的ClassLoader对象不同，那么这两个Class对象也不相等。

# 2、链接 #

类加载子系统的链接阶段主要分为验证、准备和解析三个步骤。

## 2.1 验证 ##

验证加载的Class字节码文件是否符合虚拟机规范。主要包括4种验证：文件格式验证、元数据验证、字节码验证、符号引用验证。

## 2.2 准备 ##

准备阶段为加载的类的变量分配内存并设置默认初始值，即零值。比如int类型在准备阶段初始化为0，浮点类型在准备阶段初始化为0.0。  
final static类型的变量不会被默认初始化，因为此类型的变量在编译期就被编译到字节码文件中，准备阶段直接显示的初始化赋值。  
类的实例的变量在该阶段不会被初始化，类的实例初始化是要被分配到堆上的。

如下代码所示，static代码块中首先引用了变量a，然后才对变量a初始化为了3，这种先引用后定义变量方式看似不合理，实际是可执行的。因为在准备阶段，首先会为变量a分配内存，并初始化为0，然后在下面的2.3节（初始化阶段），自上而下，先执行static块，为变量a赋值10，然后又对变量a显示初始化为3，所以最终结果输出为3。但是不可以在显示声明变量a之前引用变量a，否则会报错“非法前向引用”，但可以在声明之前进行赋值。

public class Demo1 { 
    
        static { 
            a = 10;
            //System.out.println(a); //在int a变量声明之前不可以直接饮用，可以直接赋值，否则会报错"非法前向引用"
        }
    
        private static int a = 3;
    
        public static void main(String[] args) { 
            System.out.print(Demo1.a); 		//3
        }
        
    }

## 2.3 解析 ##

应用指向目标方法的指针、相对偏移量或者间接定位目标的句柄。例如在一个类中调用了其它类的一个方法，就要在该阶段指向该方法的引用。

# 3、初始化 #

类的子系统的初始化步骤是要是执行类的构造器方法Clinit()，注意是类的构造器方法，不是初始化对象的构造器，Clinit()不需要客户定义初始化，在该阶段会初始化静态变量以及静态代码块，静态变量和静态代码块从上至下的顺序进行初始化。如下示例所示，首先执行的a=3，然后执行的静态代码块static，最后输出的a的值为10。如果类中没有静态变量或者静态代码块，同时也不会有Clinit()类的初始化方法。

public class Demo1 { 
    
        private static int a = 3;
        
        static { 
            a = 10;
        }
    
        public static void main(String[] args) { 
            System.out.print(Demo1.a); 		//10
        }
        
    }

注意只有还有静态变量或者静态代码块的类才会有Clinit初始化方法，用来初始化静态变量或者静态代码块的，除此之外还有init构造方法。类中不含有静态变量或者静态代码块的，只有init构造器。  
如果一个类A有父类B，且类A内含有静态变量或者静态代码块，会首先加载B的Clinit()方法，对B中的静态变量或者静态代码块进行初始化，然后加载A的Clinit()方法，对A中的静态变量或者静态代码块进行初始化。其次初始化B中init构造器，最后初始化A中的init构造器。

Clinit()方法在多线程并发时会加同步锁，只会有一个线程执行Clinit（）方法，并且只会有一个线程执行Clinit()方法，其它线程不会再执行Clinit()方法。如下所示

public class ClinitClass { 
    
        static { 
            System.out.println("init ClinitClass");
        }
    }

public class Demo1 { 
    
    
        public static void main(String[] args) { 
            Runnable run1 = new Runnable() { 
                @Override
                public void run() { 
                    ClinitClass clinitClass1 = new ClinitClass();
                }
            };
            Runnable run2 = new Runnable() { 
                @Override
                public void run() { 
                    ClinitClass clinitClass2 = new ClinitClass();
                }
            };
            Thread t1 = new Thread(run1);
            Thread t2 = new Thread(run2);
            t1.start();
            t2.start();
        }
    }

执行main方法，输出如下，证明Clinit方法只执行了一次，也就是说虚拟机只会执行一次类的静态变量或者静态代码块。

init ClinitClass

[20210424180459668.PNG_pic_center]: /images/20221022/c22eb52a016346d8889dfb7ef3690c33.png