欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

Java虚拟机类加载机制

程序员文章站 2022-07-15 08:04:34
...

一、概述

  虚拟机把描述类的数据从Class文件（Class文件中除了有类的描述信息外，还有常量池）加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的类加载机制。

注：这里所说的“Class文件”应当是一串二进制的字节流。

二、类加载的时机

  类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载（Loading）、验证（Verification）、准备（Preparetion）、解析（Resolution）、初始化（Initialization）、使用（Using）和卸载（Unloading）7个阶段，如下图：

Java虚拟机类加载机制 如图中所示，加载、验证、准备、初始化和卸载5个阶段的顺序是确定的，这些阶段通常都是互相交叉地混合式进行的（即：不一定是上一个阶段结束才开始下一个阶段，通常是在一个阶段执行的过程中调用、**下一个阶段）。

解析阶段在某些情况下可以在出书啊之后再开始，这是为了支持语言的运行是绑定（也称为动态绑定或者晚期绑定）。

扩展：

绑定指的是把一个方法的调用与方法所在的类(方法主体)关联起来，对java来说，绑定分为静态绑定和动态绑定：

  • 静态绑定：即前期绑定。在程序执行前方法已经被绑定，此时由编译器或其它连接程序实现。针对java，简单的可以理解为程序编译期的绑定。java当中的方法只有final，static，private和构造方法是前期绑定的。
  • 动态绑定：即晚期绑定，也叫运行时绑定。在运行时根据具体对象的类型进行绑定。在java中，几乎所有的方法都是后期绑定的。

Java虚拟机规范中并没哟强制约束说什么时候开始进行加载过程，这个交给虚拟机的具体实现来*把握，但是对于初始化阶段，虚拟机规范则是严格规定了有且只有5中情况必须对类进行“初始化”（而加载、验证、准备自然需要在此之前开始）：

       注：这一点接口的加载过程有些不同，接口在初始化时，并不要求其父接口全部都完成了初始化，只有在真正使用父接口的时候（如：引用接口中定义的常量）才会初始化。

  1. 使用new关键字实例化对象的时候、读取或设置一个类的静态字段（被final修饰、已在编译器把结果放入常量池的静态字段除外，这些都不属于类的描述信息了）
  2. 使用java.lang.reflect包的而方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。
  3. 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
  4. 当虚拟机启动时，用户需要指定一个要执行的主类（包含main（）方法的那个类），虚拟机会先初始化这个主类。
  5. 当使用JDK1.7的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法的句柄所对应的类还没有进行初始化，则需要出发其初始化。

除上述5中情况之外，所以引用类的方式都不会触发初始化，称为被动引用。

下面列几个被动引用的代码案例： 

package ClassLoadOrder;
/**
 * 被动使用类字段
 * 演示一:通过子类引用父类的静态字段，不会导致子类初始化
 * 演示二:通过数组定义来引用类，不会触发类的初始化
 * 演示三：常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化
 * @author cb
 *
 */
public class TestClassLoadOrder {
	public static void main(String[] args) {
		System.out.println("演示一结果：");
		System.out.println(SuperClass.a);
		System.out.println("演示二结果：");
		SuperClass[] sca = new SuperClass[10];//没有任何输出
		System.out.println("演示三结果：");
		System.out.println(SuperClass.str);//没有 输出SuperClass init，说明没有触发类的初始化;输出了Hello World是TestClassLoadOrder类对自身常量池的引用
	}
}
class SuperClass {
	static {
		System.out.println("SuperClass init");
	}
	public static int a = 1;
	public static final String str = "Hello World!!!";
}
class SubClass extends SuperClass{
	static {
		System.out.println("SubClass init");
	}
}


输出结果:
演示一结果：
SuperClass init
1
演示二结果：
演示三结果：
Hello World!!!

三、类加载的过程

  • 加载

     在加载阶段，虚拟机需要完成以下3件事情：

  1.  通过一个类的全限定名来获取定义此类的二进制字节流
  2.  将这个二进制字节流所代表的静态存储结构转化为方法区的运行时数据结构
  3. 在内存中生成一个代表这个类的java.lang.Class对象（堆内存），作为方法区这个类的各种数据的访问入口

虚拟机规范的这3点其实并不算具体，相对比较灵活，如第1点并没有指明二进制字节流从哪里获取、怎么获取，在Java的发展历程中，开发人员则玩出了各种花样，比如：

  • 从ZIP、JAR、EAR、WAR包中读取
  • 从网络上获取
  • 运行时计算生成，这种场景使用最多的就是动态代理计算，在java.lang.reflect.Proxy中，就是用了ProxyGenerator.generateProxyClass来为特定接口生成形式为“*$Proxy”的代理类的二进制字节流

    ......................

相对于类加载过程的其他阶段，一个非数组类的加载阶段（准确地说，是加载阶段中获取类的二进制字节流的动作）是开发人员可控性最强的，因为加载阶段既可以使用系统提供的引导加载器来完成，也可以自定义类加载器去完成（即重写一个类加载器 的loadClass()方法）。

  对于数组类而言，数组类本身不通过类加载创建，它是由Java虚拟机直接创建的。

  • 验证

   验证的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机的自身的安全。

  验证过程大致会完成以下4个阶段的检验动作：

  1. 文件格式验证

   这个阶段是验证字节流是否符合Class文件格式的规范，主要的验证点有：

  • 是否以魔术0xCAFEBABE开头
  • 主、次版本号是否在当前虚拟机处理范围之内
  • 常量池的常量中是否有不被支持的常量类型（检查常量tag标志）
  • 指向常量的各种索引值中是否有指向不存在的常量或不符合类型的常量
  • CONSTANT_Utf8_info型的常量中是否有不符合UTF8编码的数据
  • Class文件中各部分及文件本身是否有被删除或附加的其他信息

    ...............................

   这个阶段的验证是基于二进制字节流进行的，只有通过这个阶段的验证后，字节流才会进入内存的方法区中进行存储，所以后面的3个验证阶段都是基于方法区的存储结构进行的，不会再直接操作字节流。

   

      2. 元数据验证

    这个阶段是对字节码描述的信息进行语义分析，以保证其描述的信息符合Java语言规范的要求，报告的验证点如下：

  • 这个类是否有父类（除了java.lang.Object之外，所有的类都应当有父类）
  • 这个类的父类是否继承了不允许继承的类（被final修饰的类）
  • 如果这个类不是抽象类，是否实现了其父类或者接口之中要求实现的所有方法
  • 类中的字段、方法是否与父类产生矛盾（例如覆盖了父类的final字段，或者出现了不符合规则的方法重载）
  • ..................

       3. 字节码验证

       这个阶段的主要目的是通过数据流和控制流分析，确定程序语义是否合法的、符合逻辑的。（对类的方法体进行校验分析，保证被校验类的方法在运行是不会做出危害虚拟机安全的事件），如：

  • 保证任意时刻操作数栈的数据类型与指令代码序列都能配合工作，如：不会出现在操作栈上放置了一个Int类型的数据，使用时却按long类型来加载入本地变量表中
  • 保证方法体中的类型转换是有效的，如：把父类对象赋值给子类类型数据，甚至赋值给毫无继承关系的数据类型，则是危险和不合法的
  • ................

        4. 符号引用验证

         这个阶段的校验发生在虚拟机将符号引用转化为直接引用的时候，这个转化动作将在解析阶段中发生。符号引用验证可以看做是对类自身以外（常量池中的各种符号引用）的信息进行匹配性校验，校验以下内容：

  • 符号引用中通过字符串描述的全限定名是否能找到对应的类
  • 在指定类中是否存在符合方法的字段描述符以及简单名称所描述的方法和字段
  • 符号引用中的类、字段、方法的访问性（private、protected、public、default）是否可以被当前类访问
  • .....................

    符号引用验证的目的是确保解析动作能正常运行。

    对于虚拟机的类加载机制来说，验证阶段是一个非常重要但是并不是一定必要的阶段。在实施阶段可以考虑使用-Xverify:none参数来关闭大部分的类验证措施，以缩短虚拟机类加载的时间。

  • 准备

       准备阶段做两件事：为类变量在方法区中分配内存、为类变量设置初始值。

       对于该阶段有以下几点需要注意：

  • 这时候进行内存分配的仅包括类变量（static），而不包括实例变量，实例变量会在对象实例化时随着对象一块分配在Java堆中。
  • 这里所设置的初始值通常情况下是数据类型默认的零值（如0、0L、null、false等），而不是被在Java代码中被显式地赋予的值。

        假设一个类变量的定义为： public static int value=3；

      那么变量value在准备阶段过后的初始值为0，而不是3，因为这时候尚未开始执行任何Java方法，而把value赋值为3的public static指令是在程序编译后，存放于类构造器 <clinit>（）方法之中的，所以把value赋值为3的动作将在初始化阶段才会执行。

                                                                                   表          基本数据类型的零值

数据类型 零值
int 0
long 0L
short (short)0
char '\u0000'
byte (byte)0
boolean false
float 0.0f
double 0.0d
reference null

       这里还需注意几点：

1.对基本数据类型来说，对于类变量（static）和全局变量，如果不显式地对其赋值而直接使用，则系统会为其赋予默认的零值，而对于局部变量来说，在使用前必须显式地为其赋值，否则编译时不通过。
2.对于同时被static和final修饰的常量，必须在声明的时候就为其显式地赋值，否则编译时不通过；而只被final修饰的常量则既可以在声明时显式地为其赋值，也可以在类初始化时显式地为其赋值，总之，在使用前必须为其显式地赋值，系统不会为其赋予默认零值。
3.对于引用数据类型reference来说，如数组引用、对象引用等，如果没有对其进行显式地赋值而直接使用，系统都会为其赋予默认的零值，即null。
4.如果在数组初始化时没有对数组中的各元素赋值，那么其中的元素将根据对应的数据类型而被赋予默认的零值。
  •      如果类字段的字段属性表中存在 ConstantValue属性，即同时被final和static修饰，那么在准备阶段变量value就会被初始化为ConstValue属性所指定的值

 

  • 解析

       解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。

  • 符号引用（Symbolic References）：符号引用以一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可
  • 直接引用（Direct References）：直接引用可以是直接指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄。

       解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用。

 

  • 初始化 

      在初始化阶段，才真正开始执行类中定义的Java程序代码（或者说是字节码）。

      在准备阶段，变量已经赋过一次系统要求的初始值（零值），而在初始化阶段，则根据程序员通过程序制定的主观计划去出初始化类变量或者其他资源，或者可以从另外一个绝对来表达：初始化阶段是执行类构造器<clinit>()方法的过程。

 

  四、类加载器

      虚拟机设计团队把类加载阶段的“通过一个类的全限定名来获取描述此类的二进制字符流”这个动作放到了Java虚拟机外部去实现，以便让应用程序自己决定如何去获取所需要的类。实现这个动作的代码模块称为“类加载器”。

     查找类加载器代码：

public class TestClassLoadOrder {
	public static void main(String[] args) {
		ClassLoader loader = Thread.currentThread().getContextClassLoader();
		System.out.println(loader);
		System.out.println(loader.getParent());
		System.out.println(loader.getParent().getParent());
	}
}

输出结果：

aaa@qq.com
aaa@qq.com
null

从上面的结果可以看出，并没有获取到 ExtClassLoader的父Loader，原因是 BootstrapLoader（引导类加载器）是用C++语言实现的，找不到一个确定的返回父Loader的方式，于是就返回null。

从Java虚拟机的角度来讲，只存在两种不同的类加载器：启动类加载器和所有其他的类加载器；

从Java开发人员的角度来讲，绝大部分Java程序都会使用到以下3种系统提供的类加载器：

  1. 启动类加载器（Bootstrap ClassLoader）：这个类加载器负责将存放在<JAVA_HOME>\lib目录中的，或者被-Xbootclasspath参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如rt.jar,名字不符合的类库及时放在lib目录中也不会被加载）类库加载到虚拟机中。启动类加载器无法被Java程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给引导类加载器，那直接使用null代替即可。
  2. 扩展类加载器（Extension ClassLoader）：这个加载器由sun.misc.Launcher$ExtClassLoader实现，它负责加载<JAVA_HOME>\lib\ext目录中的或者被java.ext.dirs系统变量所指定的路径中的所有类库，开发者可以使用扩展类加载器。
  3. 应用程序类加载器（Application ClassLoader）：这个加载器由sun.misc.Launcher$AppClassLoader实现，也叫系统类加载器。它负责加载用户类路径(ClassPath)上的所指定的类库，开发者可以直接使用，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。

五、类的加载

类加载有三种方式：

  • 1、命令行启动应用时候由JVM初始化加载

  • 2、通过Class.forName()方法动态加载

  • 3、通过ClassLoader.loadClass()方法动态加载

 六、双亲委派模型

Java虚拟机类加载机制

        双亲委派模型的工作流程是：如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把请求委托给父加载器去完成，依次向上，因此，所有的类加载请求最终都应该被传递到顶层的启动类加载器中，只有当父加载器在它的搜索范围中没有找到所需的类时，即无法完成该加载，子加载器才会尝试自己去加载该类。

       ClassLoader源码分析：

        

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

双亲委派模型意义：

  • 防止内存中出现多份同样的字节码

如：Object类在程序的各种类加载器环境都是同一个类。相反，如果没有使用双亲委派模型，由各个类加载器自行去加载的话，如果用户自己编写了一个成为java.lang.Object的类，并放在程序的ClassPath中，那系统中将会出现多个不同的Object类，Java类型体系中最基础的行为都无法保证了。

注：任意一个类，都需要由加载它的类加载器和这个类本身一同确立其在Java虚拟机中的唯一性。

  • 保证Java程序安全稳定运行

相关标签： l

上一篇： UE4插件应用到项目_Missing Dependency

下一篇： OpenCV学习记录——2.使用OpenCV的Stitcher类来实现全景图拼接

推荐阅读