JVM的艺术之如何使用类加载器-柠檬ai自媒体

本文主要讲解“JVM的艺术如何使用类加载器”，简单明了，易学易懂。请跟随边肖的思路学习“JVM的艺术如何使用类加载器”。

00-1010 Current ClassLoader:每个类都将使用自己的类加载器(即加载自己的类加载器)来加载其他类(指它所依赖的类)。如果类引用类，那么类的类加载器将加载类(假设类还没有被加载)。

线程上下文类加载器：线程上下文类加载器是从JDK1.2引入的，类线程中的* * getcontextclassloader()*与setcontextclassloader(class loader cl)* *分别用于获取和设置上下文类加载器。如果它不是由setcontext class loader(class loader cl)设置的，线程将继承其父线程的上下文类加载器。

Java应用运行时初始线程的上下文类加载器是系统类加载器

00-1010为什么要用线程上下文类来加载？我在上一篇文章中也简单提到过。线程类加载最初设计的原因在于我们的JAVA语言的SPI机制。我也提供了一张图片，希望下面的图片能充分说明上下文类加载器的含义。 JVM的艺术之如何使用类加载器

正式介绍线程的上下文类加载器之前需要介绍一些理论性的东东

当我们使用JDBC操作数据库时，我们将写如下：

class . FOrname(' com . MySQL . driver . driver ')；

connectionconn=driver . getconnection()；

statements t=conn . GetStatement()；JDBC是一个标准，这意味着Connection和Statement在JDK都是内置标准，都是抽象接口，都位于rt.jar中，它们的实现必须由不同的数据库厂商来实现，所以问题来了：这些标准都是由根类加载器所加载的，但是具体的实现是由具体的厂商来做的，那肯定是需要将厂商的jar放到工程的classpath当中来进行使用，很显然厂商的这些类是没办法由启动类加载器去加载，会由应用类加载器去加载,根据* *，“父类加载器加载的类或接口看不到子类加载器加载的类或接口，但是，子类加载器加载的类或接口是这一原则，那么会导致这样一个局面：比如说java.sql包下面的某个类会由启动类加载器去加载，该类有可能会要访问具体的实现类，但具体实现类是由应用类加载器所加载的，java.sql类加载器是根据看不到具体实现类加载器所加载的类的，这就是基于双亲委托模型所出现的一个非常致命的问题，这种问题不仅是在JDBC中会出现，在JNDI、xml解析等, thread . currentthread()的当前线程，可见父类加载器加载的类或接口的“http://www . Sina.com/SPI(Service Provider Interface)* *场景。由指定的类加载器加载的类。getContextLoader()改变了父类加载器无法使用子类加载器加载的类或者没有直接父子关系的其他类加载器的情况，不仅改变了父委托模型。线程类加载器是当前线程的当前类加载器。在父委托模型下，类加载是自下而上的，即下层类加载器会委托上层类加载器进行加载。但是对于SPI来说，有些接口是由Java核心库提供的，由启动类加载器加载，但是这些接口的实现来自不同的jar包(厂家提供)。Java的启动类加载器不会加载其他来源的jar包，因此传统的父委托模型无法满足SPI的要求。通过为当前线程设置上下文类加载器，可以通过设置上下文类加载器来加载接口实现类。

为什么使用线程上下文类加载？

JVM的艺术之如何使用类加载器

显然，JDBC会参考特定厂商的JDBCImpl实现，而JDBC标准是由根类加载器加载的，所以特定厂商的类也会由根类加载器加载，而且因为它们是工程下的类。

sPath当中，由系统类加载器去加载，很显然是没办法由根类加载器去加载的，为了解决这个问题，线程的上下文类加载器就发挥作用了。

分析：由上面的理论可知：Java应用运行时初始线程的上下文类加载器是系统类加载器

那思考一下：为什么默认的线程上下文类加载器就是系统类加载器呢？肯定是在某个地方给设置了，其实它是在Launcher中进行设置的，如下：

1、线程上下文类加载器的一般使用模式（获取 - 使用 - 还原）

  ClassLoader classLoader = Thread.currentThread().getContextClassLoader();//获取
        try{
            ClassLoader targetTccl = xxx;//要设置的上下文类记载器
            Thread.currentThread().setContextClassLoader(targetTccl);//设置
            myMethod();//使用
        } finally {
            Thread.currentThread().setContextClassLoader(classLoader);//还原
        }

2、如果一个类由类加载器A加载，那么这个类的依赖类也是由相同的类加载器加载的（如果该依赖类之前没有被加载过的话），ContextClassLoader的作用就是为破坏Java的类加载委托机制。

3、当高层提供了统一的接口让低层来实现，同时又要在高层加载（或实例化）低层的类时，就必须要通过线程上下文类加载器来帮助高层的ClassLoader找到并加载该类。

Thread.currentThread().getContextClassLoader();//获取

Thread.currentThread().setContextClassLoader(targetTccl);//设置

至此线程上下文类加载器就介绍到这里。

类加载的过程

其实一个类从加载到使用是要经历很多个过程的，下面我们来详细的说说，一个类从加载到初始化的这个过程，然而还有哪些坑不为人知。

下面给出一张图：

固定的类加载执行顺序: 加载验证准备初始化卸载的执行顺序是一定的为什么解析过程没有在这个执行顺序中？(接下来分析)

什么时候触发类加载不一定，但是类的初始化如下四种情况就要求一定初始化。但是初始化之前就一定会执行 加载验证准备三个阶段。

触发类加载的过程(由初始化过程引起的类加载)

1):使用new 关键字获取一个静态属性设置一个静态属性调用一个静态方法。

int myValue = SuperClass.value;会导致父类初始化，但是不会导致子类初始化

SuperClass.Value = 3 ; 会导致父类初始化，不会导致子类初始化。

SubClass.staticMethod(); 先初始化父类在初始化子类

SubClass sc = new SubClass(); 先初始化父类再初始化子类

2):使用反射的时候，若发现类还没有初始化，就会进行初始化

Class clazz = Class.forName("com.hnnd.classloader.SubClass");

3):在初始化一个类的时，若发现其父类没有初始化，就会先初始化父类

SubClass.staticMethod(); 先初始化父类在初始化子类

4):启动虚拟机的时候，需要加载包含main方法的类.

 class SuperClass{
     public static int value = 5;
     
     static {
      
      System.out.println("Superclass ...... init........");
     }
    }
    
    class SubClass extends SuperClass {
     
     static {
      System.out.println("subClass********************init");
     }
     
     public static void staticMethod(){
      System.out.println("superclass value"+SubClass.value);
     }
    }

下面我们对类的加载、连接、初始化这几个过程逐一的解释：

1:加载

1.1)根据全类名获取到对应类的字节码流(字节流的来源 class 文件，网络文件，还有反射的Proxygeneraotor.generaotorProxyClass)

1.2)把字节流中的静态数据结构加载到方法区中的运行时数据结构

1.3)在内存中生成java.lang.Class对象，可以通过该对象来操作方法区中的数据结构(通过反射)

2:验证

文件格式的验证: 验证class文件开头的0XCAFFBASE 开头

验证主次版本号是否在当前的虚拟机的范围之类

检测jvm不支持的常量类型

元数据的校验:

验证本类是否有父类

验证是否继承了不允许继承的类(final)修饰的类

验证本类不是抽象类的时候，是否实现了所有的接口和父类的接口

**字节码验证:**验证跳转指令跳转到方法以外的指令.

验证类型转换是否为有效的，比如子类对象赋值父类的引用是可以的，但是把父类对象赋值给子类引用是危险的

总而言之:字节码验证通过，并不能说明该字节码一定没有问题，但是字节码验证不通过。那么该字节码文件一定是有问题：。

符号引用的验证(发生在解析的过程中)：

通过字符串描述的全类名是否能找到对应的类。

指定类中是否包含字段描述符，以及简单的字段和方法名称。

3:准备:为类变量分配内存以及设置初始值。

比如public static int value = 123;

在准备的过程中 value=0 而不是123 ，当执行类的初始化的方法的时候，value=123

若是一个静态常量

public static final int value = 9; 那么在准备的过程中value为9.

4:解析：把符号引用替换成直接引用

符号引用分类:

CONSTANT_Class_info 类或者接口的符号引用

CONSTANT_Fieldref_info 字段的符号引用

CONSTANT_Methodref_info 方法的符号引用

CONSTANT_intfaceMethodref_info- 接口中方法的符号引用

CONSTANT_NameAndType_info 子类或者方法的符号引用.

CONSTANT_MethodHandle_Info 方法句柄

CONSTANT_InvokeDynamic_Info 动态调用

直接引用:

指向对象的指针

相对偏移量

操作句柄

5:初始化：类的初始化时类加载的最后一步:执行类的构造器，为所有的类变量进行赋值(编译器生成CLInit<>)

类构造器是什么？：类构造器是编译器按照Java源文件总类变量和静态代码块出现的顺序来决定

静态语句只能访问定义在静态语句之前的类变量，在其后的静态变量能赋值但是不能访问。

父类中的静态代码块优先于子类静态代码块执行。

若类中没有静态代码块也没有静态类变量的话，那么编译器就不会生成 Clint<>类构造器的方法。

public class TestClassInit {
 public static void main(String[] args) {
  System.out.println(SubClass.sub_before_v);
 }
}

class SubClass extends SuperClass{
 public static int sub_before_v = 5;
 static {
  sub_before_v = 10;
  System.out.println("subclass init.......");
  sub_after_v=0;
  //报错,static代码块中的代码只能赋值后面的类变量 但是不能访问。
  sub_before_v = sub_after_v;
 }
 public static int sub_after_v = 10;
}

class SuperClass {
 public static int super_before_v = 5;
 static{
  System.out.println("superclass init......");
 }
 public static int super_after_v = 10;
}

下面我们通过一系列的案例来说验证上面所说的。先做个小的总结。

类的初始化需要对类进行主动使用，下面总结了几点，都可以看做是对类的主动使用：

1：创建类的实例。

2：访问某个类或者接口中的静态变量，或者对其赋值。

3：访问某个类的静态方法。

4：反射。

5：初始化一个类的子类。

6：包含main方法的类。

7：jdk1.7开始提供动态语言的支持。

除了以上7种情况，都是被动使用，都不会导致类被初始化。

根据以上结论，我们来写几个案例，针对每种情况进行一下证明。

结论一：

静态常量初始化过程是，在jvm连接之后，静态常量的初始化，是由调用这个静态常量方法所在的类的常量池中被保存，此时，被调用的静态常量所在的类的class文件就可以被删除，即使被删除，该常量依然有效。调用某个类的静态常量不能初始化该类。

代码：

package com.jdyun.jvm001;

public class TestClass03 {

    public static void main(String[] args) {

        System.out.println(Pet1.a);
    }
}

class Pet1{

    public static final int a = 10;

    static {
        System.out.println("我是Pet1，我被初始化了");
    }
}

运行结果：
"C:\Program Files\Java\jdk-11.0.2\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=64451:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath G:\jdyun-jvm\out\production\jdyun-jvm com.jdyun.jvm001.TestClass03
10

Process finished with exit code 0

从上面这个案例可知，一个类调用另一个类的常量不会导致一个类的初始化。

结论二：

此处声明的静态常量，按照之前的理解是静态常量被调用不会初始化该静态常量所在的类
但是此处当静态常量的值是一个引用类型的时候，这个时候该静态常量所在的类就会被初始化
故此会先打印我被初始化了，然后在打印a的随机值

代码：

package com.jdyun.jvm001;

import java.util.UUID;

public class TestClass03 {

    public static void main(String[] args) {
        System.out.println(Pet1.a);

    }
}

class Pet1{
    public static final String a = UUID.randomUUID().toString();

    static{
        System.out.println("我被初始化了");
    }
}

运行结果：
    
"C:\Program Files\Java\jdk-11.0.2\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=50237:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath G:\jdyun-jvm\out\production\jdyun-jvm com.jdyun.jvm001.TestClass03
    
我被初始化了
e5b56749-5a97-405f-9fe9-dfe4211bc0ce

Process finished with exit code 0

结论三：

静态变量初始化与静态常量初始化不同，静态变量初始化是在初始化阶段被赋予真实的值比如int a = 2，那么2会被真正的赋值给a。

如果某个类调用了该类的静态变量，那么静态变量所在的类就会被视为被主动调用了。那么该类就会被初始化。

该类如果有静态代码块儿那么静态代码块儿的优先级高于静态变量。

如果该静态变量所在的类中有父类，那么会优先初始化父类。

package com.jdyun.jvm001;

import java.util.Random;
import java.util.UUID;

public class TestClass03 {

    public static void main(String[] args) {

        System.out.println(Dog3.a);

    }
}

class Dog3 extends Pet1{

    public static final  int a = new Random().nextInt();

    static {
        System.out.println("我是Pet1，我是父类，我被最先加载了");
    }

}

class Pet1{

    static{
        System.out.println("我被初始化了");
    }
}

运行结果：
    
"C:\Program Files\Java\jdk-11.0.2\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=64951:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath G:\jdyun-jvm\out\production\jdyun-jvm com.jdyun.jvm001.TestClass03
                    
我被初始化了
我是Pet1，我是父类，我被最先加载了
-1203457101

Process finished with exit code 0

结论四：

验证初始化次数，只会被初始化一次。

package com.jdyun.jvm001;


import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.UUID;

public class MyTest02  extends  ClassLoader{

    public static void main(String[] args) throws ClassNotFoundException {
        //1,验证初始化次数
        for(int i=0;i<50;i++){
            Test01 test01 = new Test01();
        }

    }
}

class Test01{

    static{
        System.out.println("我被初始化了");
    }
}

运行结果：
    
"C:\Program Files\Java\jdk-11.0.2\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=65340:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath G:\jdyun-jvm\out\production\jdyun-jvm com.jdyun.jvm001.MyTest02
我被初始化了

Process finished with exit code 0

结论五：

接口的初始化，子接口的初始化不会导致父接口的初始化，如果可以导致父接口的初始化，那么Test01类中的静态代码块儿就会被打印。很显然结果来看，Test01

中的静态代码块儿没有被打印，所以，接口的初始化中，子接口的初始化，不会导致父接口的初始化。

package com.jdyun.jvm001;


import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.UUID;

public class MyTest02  extends  ClassLoader{

    public static void main(String[] args) throws ClassNotFoundException {

        //2,接口初始化,子接口的初始化不会导致父接口的初始化
        System.out.println(MyChild.b);
       /* System.out.println(MyParent.test01);
        System.out.println(MyChild.test001);*/

        //3,反射初始化类
        //Class.forName("com.jdyun.jvm001.Test01");

        //4,创建数组不会导致类的初始化
        //Test01[] test01 = new Test01[1];

        //5,静态变量赋值
        //System.out.println(MyChild.b);

        //Class clesses = String.class;


    }
}

class Test01{

    static{
        System.out.println("Test01被初始化了");
    }
}

interface MyParent{

    Test01 test01 = new Test01();

    public static final String a="5";

}

interface MyChild extends MyParent {

    public static  Integer b= UUID.randomUUID().hashCode();


}
"C:\Program  Files\Java\jdk-11.0. 2\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=49632:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath G:\jdyun-jvm\out\production\jdyun-jvm com.jdyun.jvm001.MyTest02
-221561202

Process finished with exit code 0

结论六：

创建一个数组，不会导致类的初始化。

package com.jdyun.jvm001;


import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.UUID;

public class MyTest02  extends  ClassLoader{

    public static void main(String[] args) throws ClassNotFoundException {

        //4,创建数组不会导致类的初始化
        Test01[] test01 = new Test01[1];
    }
}

class Test01{

    static{
        System.out.println("Test01被初始化了");
    }
}

运行结果：

"C:\Program Files\Java\jdk-11.0.2\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=50058:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath G:\jdyun-jvm\out\production\jdyun-jvm com.jdyun.jvm001.MyTest02

Process finished with exit code 0

结论七：

此处声明的静态常量，按照之前的理解是静态常量被调用不会初始化该静态常量所在的类但是此处当静态常量的值是一个引用类型的时候，这个时候该静态常量所在的类就会被初始化故此会先打印我被初始化了，然后在打印a的随机值

package com.jdyun.jvm07;

import java.util.Random;
import java.util.UUID;

/**
 * 此处声明的静态常量，按照之前的理解是静态常量被调用不会初始化该静态常量所在的类
 * 但是此处当静态常量的值是一个引用类型的时候，这个时候该静态常量所在的类就会被初始化
 * 故此会先打印我被初始化了，然后在打印a的随机值
 */
public class Test  {

    public static void main(String[] args) {

        System.out.println(Pet.a);

    }
}

class Pet{

    public static final String a = UUID.randomUUID().toString();

    static{

        System.out.println("我被初始化了");
    }
}
运行结果：
"C:\Program Files\Java\jdk-11.0.2\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=50995:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath G:\jdyun-jvm\out\production\jdyun-jvm com.jdyun.jvm07.Test
我被初始化了
3febaad7-90fe-4d7f-be1c-62b70b9f41cc

Process finished with exit code 0

结论八：

对子接口静态常量调用时，父接口没有被加载也并没有被初始化。当我们有两个接口，父子接口，然后在子接口中声明一个静态变量，此时对子接口中的静态变量进行主动调用，此时父接口没有被初始化，也没有被加载。（删除父接口中的class）

package com.jdyun.jvm8;

import java.util.Random;

public class Test {

    public static void main(String[] args) {
        System.out.println(MyChild.b);
    }

}

interface MyParent{

    public static final String a="5";

}

interface MyChild extends MyParent{

    public static  Integer b= 1;
}

运行结果：
    
"C:\Program Files\Java\jdk-11.0.2\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\lib\idea_rt.jar=51297:C:\Program Files\JetBrains\IntelliJ IDEA 2019.2\bin" -Dfile.encoding=UTF-8 -classpath G:\jdyun-jvm\out\production\jdyun-jvm com.jdyun.jvm8.Test
1

Process finished with exit code 0

结论九：

接口中的变量赋予引用初始值会初始化子接口。

public class Test {

    public static void main(String[] args) {
        System.out.println(MyChild.b);
    }

}

interface MyParent{

    public static String a=5;

}

interface MyChild extends  MyParent{

    Integer b= new Random().nextInt(2);
}

感谢各位的阅读，以上就是“JVM的艺术之如何使用类加载器”的内容了，经过本文的学习后，相信大家对JVM的艺术之如何使用类加载器这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是，小编将为大家推送更多相关知识点的文章，欢迎关注！

内容来源网络，如有侵权，联系删除，本文地址：https://www.230890.com/zhan/43717.html