JVM——虚拟机类加载机制

最新推荐文章于 2019-10-26 10:35:12 发布

Richard331

最新推荐文章于 2019-10-26 10:35:12 发布

阅读量139

点赞数

分类专栏： JVM Java

本文链接：https://blog.csdn.net/richard331/article/details/89608031

版权

Java 同时被 2 个专栏收录

24 篇文章 0 订阅

订阅专栏

JVM

13 篇文章 0 订阅

订阅专栏

概述

虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的类加载机制。
在Java语言里面，类型的加载、连接和初始化过程都是程序运行期间完成的，这种策略虽然会令类加载时稍微增加一些性能开销，但是会为Java应用程序提供高度的灵活性，Java里天生可以动态扩展的语言特性就是依赖运行期动态加载和动态连接这个特点实现的。

类加载的时机

类从加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载（Loading）、验证（Verfication）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（Using）和卸载（Unloading）7个阶段。
验证、准备、解析这三部分被统称为连接（Linking）

—————————————————————————————————
加载——> 验证——> 准备——> 解析——> 初始化——> 使用——> 卸载
—————————————————————————————————

**加载、验证、准备、初始化和卸载这5个阶段的顺序是确定的，类的加载过程按照这种顺序按部就班地开始，而解析阶段则不一定：它在某些情况下可以初始化阶段之后在开始，这是为了支持Java语言的运行时板顶（也称动态绑定或晚期绑定）

Java虚拟机规范中并没有进行规定什么时候开始加载，由Java虚拟机的具体实现来自由把握。但是对于初始化阶段，虚拟机规范则是严格规定了有且只有5种情况必须立即对类进行“初始化”。（而加载、验证、准备在初始化之前完成）。

遇到new、getstatic、putstatic或invokestatic这4条字节时，如果类没有进行过吃石化，则需要先触发其初始化。生成这4条指令的最常见的Java代码场景是：使用new关键字实例化对象的时候、读取或设置一个类的静态字段（被final修饰、已在编译器把结果放入常量池的静态字段外）的时候，以及调用一个类的静态方法时。
使用Java.lang.reflect包的方法对类进行反射调用时候，如果类没有进行初始化则先需要出发其初始化。
当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要触发其父类的初始化。
当虚拟机启动时，用户需要制定一个执行的主类（包含main()方法的那个类），虚拟机会优先初始化这个类。
当使用JDK的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_incokeStatic的方法句柄，并且这个方法句柄对应的类没有进行初始化，则需要先触发其初始化，称为被动引用。下面3个例子来说明何为被动引用，代码如下
例子1：

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

    public static int value = 123;
}

public class SubClass extends SuperClass {
    static {
        System.out.println("SubClass init");
    }
}

public class NotInitialization {

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

输出
在这里插入图片描述

输出了“SuperClass init”，而不会输出"SubClass init"。对于静态字段，只有直接定义这个字段的类才会被初始化，因此通过其子类引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。是否要触发子类的加载和验证，虚拟机规范中并没有明确规定，这点取决于虚拟机的具体实现。
将类NotInitialization改为：

public class NotInitialization {

    public static void main(String[] args) {
        new SuperClass();
        System.out.println();
        new SubClass();
    }
}

输出：
在这里插入图片描述

将类NotInitialization改为：

public class NotInitialization {

    public static void main(String[] args) {
        new SubClass();
        System.out.println();
        new SuperClass();
    }
}

在这里插入图片描述

例子2：

public class NotInitialization {

    public static void main(String[] args) {

        SuperClass[] sca = new SuperClass[10];
    }
}

在这里插入图片描述
创建了SuperClass的数组，但是并没有输出“SuperClass init”，说明并没有触发com.vma.invoke.SuperClass的初始化过程。但是这段代码触发了另外一个名为：“[Lcom.vma.invoke.SuperClass”的初始化阶段，对于用户代码来说，这并不是一个合法的类名称，这是一个由虚拟机自动生成的、直接继承于java.lang.Object的子类，创建动作由字节码newarray触发。

这个类代表了一个元素类型：com.vma.invoke.SuperClass的一维数组，数组中应有的属性和方法都实现在这个类里。

例子3：

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

    public static final String HELLOWORD = "hello world";
}

public class NotInitialization {

    public static void main(String[] args) {

        System.out.println(ConstClass.HELLOWORD);
    }
}

在这里插入图片描述
运行后没有输出“ConstClass init”，这是因为虽然在Java源码中引用了ConstClass类中的常量HELLOWORLD,但其实在编译阶段通过常量传播优化，已经将此常量的值“hello world”存储到NotInitialization类的常量池中，优化NotInitialization对常量ConstClass.HELLOWORLD的引用实际都被转化为NotInitialization类对自身常量池的引用了。也就是说，实际上NotInitialization的Class文件之中并没有ConstClass类的符号引用入口，这两个雷在编译成Class文件之后就不存在任何联系了。

加载

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

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

在Java虚拟机中的这3点要求并不算具体，一次虚拟机实现与具体应用的灵活度都是相当大的。例如“通过一个类的全限定名获取定义此类的二进制字节流”，它没有知名二进制字节流要从一个Class文件中获取，准确地说是根本没有指明要从哪里获取、怎样获取。可以通过以下的手段来获取：

从ZIP包中读取，这很常见，最终成为日后的JAR、EAR、WAR格式的基础
从网络中获取，如Applet
运行时计算生成，这种场景使用得最多的就是动态代理技术，在java.lang.reflect.Proxy中，就是用了ProxyGenerator.generateProxyClass来为特定接口生成形式为："*$Proxy"的代理类的二进制流。
由其他文件生成，典型场景就是JSP应用，即由JSP文件生成对应的Class类。
从数据库中读取，少见…
…

相对于类加载过程的其他阶段，一个非数组类的加载阶段是开发人员可控的，因为加载阶段即可以使用系统提供的引导类加载器来完成，也可以由用户自定义的类的加载器去完成，开发人员可以通过定义自己的类加载器去控制字节流获取方式（即重写一个类加载器的loadClass()方法）。

对于数组类而言，情况就不一样。数组类本身不通过类加载器创建，它是由Java虚拟机直接创建的。但数组类与类加载器仍然有密切的关系，因为数组类的元素类型（SuperClass[] sca,元素类型指：SuperClass）最终是靠类加载器去创建，一个数组类创建过程遵循以下规则：

如果数组的组件是引用类，那就递归采用定义的加载过程去加载这个组件类型，数组C将在加载该组件类型的类加载器的类名称空间上被标识。
如果数组的组件不是引用类型，Java虚拟机将会把数组C标记为与引导类加载器关系。
数组类的可见性与它的组件类型的可见性一致，如果组件类型不是引用类型，那数组类的可见性将默认为public。

加载完成后，虚拟机外部的二进制字节流就按照虚拟机所需的格式存储方法区之中，方法区中的数据存储格式由虚拟机实现自行定义，虚拟机规范未规定此区域的具体数据结构。**如果在内存中实例化一个java.lang.Class类的对象（并没有并且规定是在Java堆中，对于HotSpot虚拟机而言，Class对象比较特殊，它虽然是对象，但是存放在方法区里面），这个对象将作为程序访问方法区中的这些类型数据的外部接口。
在这里插入图片描述加载阶段与连接阶段的部分内容（如一部分字节码文件格式验证动作）是交叉进行的，加载尚未完成，连接阶段可能已经开始，但这些加载加载阶段之中的动作，仍然属于连接阶段的内容，这两个阶段的开始时间仍然保持固定的先后顺序。

验证

验证阶段是连接阶段的第一步，这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求并且不会危害虚拟机自身的安全。验证是虚拟机对自身保护的一项重要工作，验证主要完成下面4个校验动作：文件格式验证、元数据验证、字节码验证、符号引用验证。

文件格式验证

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

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

元数据验证

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

这个类是否有父类
这个类的父类是否继承了不允许被继承的类
如果这个类不是抽象类，是否实现了其父类或接口指针要求实现所有的方法
类中的字段、方法是否与父类产生矛盾（例如覆盖了父类的final字段，或者出现不符合规则的方法重载，例如方法参数一致，但返回结果类型却不同等）。
…

字节码验证

第三阶段是整个验证过程中最复杂的一个阶段，主要目的是**通过数据流和控制流分析，确定程序语义是否合法的、符合逻辑的。**在第二阶段对元数据信息中的数据类型做完校验后这个阶段对类的方法进行校验分析，保证被校验类的方法在运行时不会做出危害虚拟机安全的事件，例如：

保证任意时刻操作数栈的数据类型与指令代码序列都能配合，例如不会出现类似的情况，在操作栈放置了一个int类型的数据，使用时却按long类型来加载人本地变量表中。
保证跳转指令不会跳转到方法体以外的字节码指令上
保证方法体重的类型转换是有效的
…

符号引用验证

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

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

准备

准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区进行分配。这个阶段有两个容易产生混淆的概念：首先，这个时候进行内存分配的仅包括类变量（被static修饰的变量），而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在Java堆中。其次，这里所说的初始化的值“通常情况”下是数据类型的零值，假设一个变量的定义为：
public static int value = 123;
那变量value在准备阶段过后的初始值为0而不是123，因为这个时候尚未开始执行任何Java方法，而把value赋值为123的putstatic指令是程序被编译后，存放在类构造器< clint >()方法之中，所以把value赋值为123的动作将在初始化阶段才会执行。

基本数据类型的零值

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

若：
public static final int value = 123;
编译时Javac将会为value生成ConstantValue属性，在准备阶段虚拟机就会根据ConstantValue的设置将value赋值为123。

解析

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

符号引用（Symbolic References）：符号引用以一组符号来描述所引用的目标，符号可以是如何形式的字面量，只要使用时能无歧义地定位到目标即可。符号引用与虚拟机内存实现的内存布局无关，引用的目标并不一定已经加载到内存中。各种虚拟机实现的内存布局可以各不相同，但它们能接受的符号引用必须都是一致的，因为符号引用的字面量形式明确定义在Java虚拟机规范的Class文件格式中。
直接引用（Direct Reference）：直接引用可以是直接指向目标的指令、相对偏移量或是一个能间接定位到目标的句柄。直接引用是和虚拟机实现的内存布局相关，同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同。如果有了直接引用，那引用的目标必定已经在内存中存在。

初始化

类的初始化阶段是类加载过程的最后一步，前面的类加载过程中，除了在加载阶段用户应用程序可以通过自定义加载器参与外，其余动作完全由虚拟机主导和控制。到了初始化阶段，才真正开始执行类中定义的Java代码（或者说字节码）

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

< clinit>()方法是由编译器自动收集类中的所有变量的赋值动作和静态语句块（static{}块）中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块中能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块可以赋值，但是不能访问：

public class Test{
    static{
    		i = 0;
    		System.out.print(i);
    }
    static int i = 1;
}

编译能通过，但是编译器会提示非法向前引用

< clinit>()方法与类的构造函数不同，它不需要显式地调用父类构造器，虚拟机会保证在子类的< clinit>()方法之前，父类< clinit>()已经执行完成。因此在虚拟机中第一个被执行的< clinit>()肯定是java.lang.Object。
由于父类的< clinit>()方法先执行，也就意味着父类中定义的静态语句块都要优先于子类的变量赋值操作，字段B的值回收2而不是1。

public class Parent {
    public static int A = 1;

    static {
        A = 2;
    }

    static class Sub extends Parent {
        public static int B = A;
    }

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

输出：2

< clinit>()方法对于类或接口来说并不是必需的，如果一个类中没有静态语句块，也没有对变量的赋值操作，那么编译器可以不为这个类生产 < clinit>()方法。
接口中不能使用静态语句块，但仍然有变量初始化的赋值操作，因此接口与类一样都会生产 < clinit>()方法。但接口与类不同的是，执行接口的 < clinit>()方法不需要先执行父类接口的 < clinit>()方法。只有当父类接口中定义的变量使用时，父类接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的 < clinit>()方法。
虚拟机会保证一个类的 < clinit>()方法在多线程环境中被正确地加锁、同步，如果多线程同时去初始化一个类，那么只会有一个线程去执行这个类的 < clinit>()方法，其他多线程都需要阻塞等待，知道活动线程执行 < clinit>()方法完毕。如果在一个类的 < clinit>()方法中有耗时很长的操作，就会可能造成多个线程阻，在实际应用中这种阻塞往往是很隐蔽的。

类加载器

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

类与类加载器
类加载器输入只用于实现类的加载动作，但它在Java程序中起到的作用却远远不限于类加载阶段。对于任意一个类，都需要由加载它的类加载器和这个类本身一同确定其在Java虚拟机中的唯一性，每一个类加载器，都拥有一个独立的类名称空间。 这句话可以表达得更通俗一些：比较两个类是否“相等”，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一个Class文件，被同一个虚拟机加载，只要加载它们的类加载器不同，那么这两个类就必定不相等。

代码：

package com.vma.invoke;

import java.io.IOException;
import java.io.InputStream;

/**
 * <p>
 * 描述
 * </p>
 *
 * @author nicaide
 * @Date 2019/4/28 0028 16:16
 */
public class ClassLoaderTest {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {

        ClassLoader myLoader = new ClassLoader() {
            @Override
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                try {
                    String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
                    InputStream is = getClass().getResourceAsStream(fileName);
                    if (is == null) {
                        return super.loadClass(name);
                    }
                    byte[] b = new byte[is.available()];
                    is.read(b);
                    return defineClass(name, b, 0, b.length);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return super.loadClass(name);
            }
        };

        Object obj = myLoader.loadClass("com.vma.invoke.ClassLoaderTest").newInstance();

        System.out.println(obj.getClass());
        System.out.println(obj instanceof com.vma.invoke.ClassLoaderTest);
    }
}

运行结果：
在这里插入图片描述
上面代码构造了一个简单的类加载器，它可以加载与自己在同一路径下的Class文件。我们使用这个类加载器去加载一个名为“com.vma.invoke.ClassLoaderTest”的类，并实例化了这个类的对象。两行输出结果中，从第一句可以看出，这个对象确实是类com.vma.invoke.ClassLoaderTest实例化出来的对象，但从第二句可以发现，这个对象与类com.vma.invoke.ClassLoaderTest做所属类型检查的时候却返回了false，这是因为虚拟机中存在了两个ClassLoadTest类，一个是由系统应用程序类加载器加载的，另一个是由我们自定义的类加载器加载的，虽然都来自同一个Class文件，但仍然是两个独立的类，做对象所属类型检查时结果自然为flase。

双亲委派模型

从Java虚拟机的角度来讲，分为两种类加载器：一种是启动类加载器（Bootstrap CLassLoad），这个类加载器使用C++语言实现，是虚拟机自身的一部分；另一种就是所有其他的类加载器，这些类加载器都由Java语言实现，独立于虚拟机外部，并且都会继承自抽象类java.lang.ClassLoader。

从Java开发人员角度看来，类加载器还可以划分为更细致一些，绝大部分Java程序都会使用到一下3种系统提供的类加载器。

启动类加载器（Bootstrap ClassLoader）：Bootstrp加载器是用C++语言写的，它是在Java虚拟机启动后初始化的，它主要负责加载%JAVA_HOME%/jre/lib,-Xbootclasspath参数指定的路径以及%JAVA_HOME%/jre/classes中的类。
扩展类加载器（Extension ClassLoader）:这个加载器由sum.misc.Launcher$ExtClassLoader实现，它负责加载< JAVA_HOME>\lib\ext目录中的，或者被java.ext.dirs系统变量所指定的路径中的所有类库，开发者可以直接使用扩展类加载器。
应用程序类加载器（Application ClassLoader）：这个类加载器由sun.misc.Launcher$AppClassLoader实现。由于这个类加载器是ClassLoader中的getSystemClassLoader()方法的返回值，所以一般也称它为系统类加载器。它负责加载用户类路径（ClassPath）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。

应用程序都是由这3中类加载器相互配合进行加载的，如果有必要，还可以加入自己定义的加载器。关系如下:
在这里插入图片描述
如图所示的加载器之间的这种层次关系，称为类加载器的双亲委派模型（Parents Delegation Model）。双亲委派模型要求除了顶层的类加载器外，其余的类加载器都应有自己的父亲加载器。这里类加载器之间的父子关系一般不会以基础关系来实现，而都是使用组合关系来复用父加载器的代码。

这个过时就不写了，去看看热部署比这个好多了

Richard331

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JVM——虚拟机类加载机制

概述虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的类加载机制。在Java语言里面，类型的加载、连接和初始化过程都是程序运行期间完成的，这种策略虽然会令类加载时稍微增加一些性能开销，但是会为Java应用程序提供高度的灵活性，Java里天生可以动态扩展的语言特性就是依赖运行期动态加载和动态连接这个特点实...
复制链接

扫一扫