JVM类加载机制

最新推荐文章于 2024-02-18 11:26:38 发布

细嗅蔷薇的大老虎

最新推荐文章于 2024-02-18 11:26:38 发布

阅读量163

点赞数

分类专栏： JVM 文章标签： jvm

本文链接：https://blog.csdn.net/weixin_40472874/article/details/108288306

版权

JVM 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

简介

编写的java代码经过编译后变成.class文件，最终经过jvm的加载才能变成元数据区的class对象，进而执行我们的逻辑。
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。
在这里插入图片描述

类的生命周期和加载过程

在这里插入图片描述一个类在 JVM 里的生命周期有 7 个阶段，分别是加载（Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（Using）、卸载（Unloading），其中【验证、准备、解析】也叫连接。

类加载的时机

《Java虚拟机规范》严格规定了有且只有六种情况必须立即对类进行“初始化”（而加载、验证、准备自然需要在此之前开始）:
(1). 遇到new、getstatic、putstatic或invokestatic这四条字节码指令时，如果类型没有进行过初始化，则需要先触发其初始化阶段。
能够生成这四条指令的典型Java代码场景有：
★使用new关键字实例化对象的时候。
★读取或设置一个类型的静态字段（被final修饰、已在编译期把结果放入常量池的静态字段除外）的时候。
★调用一个类型的静态方法的时候。
(2). 使用java.lang.reflect包的方法对类型进行反射调用的时候，如果类型没有进行过初始化，则需要先触发其初始化。
(3). 当初始化类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
(4). 当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。
(5). 当使用JDK 7新加入的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果为REF_getStatic、REF_putStatic、REF_invokeStatic、REF_newInvokeSpecial四种类型的方法句柄，并且这个方法句柄对应的类没有进行过初始化，则需要先触发其初始化。
(6). 当一个接口中定义了JDK 8新加入的默认方法（被default关键字修饰的接口方法）时，如果有这个接口的实现类发生了初始化，那该接口要在其之前被初始化。

对于这六种会触发类型进行初始化的场景，《Java虚拟机规范》中使用了一个非常强烈的限定语 ——“有且只有”，这六种场景中的行为称为对一个类型进行主动引用。除此之外，所有引用类型的方式都不会触发初始化，称为被动引用。

同时以下几种情况不会执行类初始化：
★通过子类引用父类的静态字段，只会触发父类的初始化，而不会触发子类的初始化。
★ 定义对象数组，不会触发该类的初始化。
★ 常量在编译期间会存入调用类的常量池中，本质上并没有直接引用定义常量的类，不会触发定义常量所在的类。
★通过类名获取 Class 对象，不会触发类的初始化，Hello.class 不会让 Hello 类初始化。
★ 通过 Class.forName 加载指定类时，如果指定参数 initialize 为 false 时，也不会触发类初始化，其实这个参数是告诉虚拟机，是否要对类进行初始化。Class.forName(“jvm.Hello”)默认会加载 Hello 类。
★ 通过 ClassLoader 默认的 loadClass 方法，也不会触发初始化动作（加载了，但是不初始化）。

示例1：

public class ConstClass {
    static {
        System.out.println("常量类被初始化。");
    }
    //final修饰即为常量，移除final该类会初始化。
    public static final String HELLOWORLD = "hello world";
}
public class NotInitialization{
    public static void main(String[] args) {
        System.out.println(ConstClass.HELLOWORLD);
    }
}
结果：hello world

ConstClass类的常量HELLOWORLD，但其实在编译阶段通过常量传播优化，已经将此常量的值“hello world”直接存储在NotInitialization类的常量池中，以后NotInitialization对常量 ConstClass.HELLOWORLD的引用，实际都被转化为NotInitialization类对自身常量池的引用了。也就是说，实际上NotInitialization的Class文件之中并没有ConstClass类的符号引用入口，这两个类在编译成 Class文件后就已不存在任何联系了。

示例2：

public class ConstClass {
    static {
        System.out.println("常量类被初始化。");
    }
    public static final String HELLOWORLD = "hello world";
}
public class NotInitialization{
    public static void main(String[] args) {
    	//通过数组定义来引用类，不会触发此类的初始化
        ConstClass[] constClass = new ConstClass[10];
        System.out.println("初始化数组");
    }
}
结果：初始化数组

上面实验可知，定义对象数组，不会触发该类的初始化。

类加载—加载阶段

根据明确知道的 class 完全限定名, 来获取二进制 classfile 格式的字节流，简单点说就是找到文件系统中/jar 包中/或存在于任何地方的“class 文件”。如果找不到二进制表示形式，则会抛出 NoClassDefFound 错误。
装载阶段并不会检查 classfile 的语法和格式。类加载的整个过程主要由 JVM 和 Java 的类加载系统共同完成，当然具体到 loading 阶段则是由 JVM 与具体的某一个类加载器（java.lang.classLoader）协作完成的,一般来讲分3步：
（1）通过一个类的全限定名来获取定义此类的二进制字节流。
★ （从ZIP压缩包中读取，从网络中获取，运行时计算生成…）
（2）将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
★ (加载阶段结束后，Java虚拟机外部的二进制字节流就按照虚拟机所设定的格式存储在方法区之中了，方法区中的数据存储格式完全由虚拟机实现自行定义)
（3）在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。
★加载阶段会在Java堆内存中实例化一个java.lang.Class类的对象，此时堆里有类的实例。

类加载—验证阶段

验证是连接阶段的第一步，这一阶段的目的是确保Class文件的字节流中包含的信息符合《Java虚拟机规范》的全部约束要求，保证这些信息被当作代码运行后不会危害虚拟机自身的安全。
（1）文件格式验证：
是否以魔数0xCAFEBABE开头；主、次版本号是否在当前Java虚拟机接受范围之内；常量池的常量中是否有不被支持的常量类型（检查常量tag标志）…
（2）元数据验证:
这个类是否有父类（除了java.lang.Object之外，所有的类都应当有父类)；这个类的父类是否继承了不允许被继承的类（被final修饰的类）;
如果这个类不是抽象类,是否实现了其父类或接口之中要求实现的所有方法;
类中的字段、方法是否与父类产生矛盾（例如覆盖了父类的final字段，或者出现不符合规则的方法重载，例如方法参数都一致，但返回值类型却不同等）…
（3）字节码验证:
在第二阶段对元数据信息中的数据类型校验完毕以后，这阶段就要对类的方法体（Class文件中的Code属性）进行校验分析，保证被校验类的方法在运行时不会做出危害虚拟机安全的行为,保证方法体中的类型转换总是有效的，例如可以把一个子类对象赋值给父类数据类型，这是安全的，但是把父类对象赋值给子类数据类型，甚至把对象赋值给与它毫无继承关系、完全不相干的一个数据类型，则是危险和不合法的…
（4）符号引用验证
最后一个阶段的校验行为发生在虚拟机将符号引用转化为直接引用的时候，这个转化动作将在连接的第三阶段——解析阶段中发生。符号引用验证可以看作是对类自身以外（常量池中的各种符号引用）的各类信息进行匹配性校验，通俗来说就是，该类是否缺少或者被禁止访问它依赖的某些外部类、方法、字段等资源。本阶段通常需要校验下列内容：
·符号引用中通过字符串描述的全限定名是否能找到对应的类。
·在指定类中是否存在符合方法的字段描述符及简单名称所描述的方法和字段
·符号引用中的类、字段、方法的可访问性（private、protected、public、）是否可被当前类访问。

类加载—准备阶段

准备阶段是正式为类中定义的变量（即静态变量，被static修饰的变量）分配内存并设置类变量初始值的阶段，从概念上讲，这些变量所使用的内存都应当在方法区中进行分配，但必须注意到方法区本身是一个逻辑上的区域，在JDK 7及之前，HotSpot使用永久代来实现方法区时，实现是完全符合这种逻辑概念的；而在JDK 8及之后，类变量则会随着Class对象一起存放在Java堆中，这时候“类变量在方法区”就完全是一种对逻辑概念的表述了。堆里真正存放着类变量。
关于准备阶段，还有两个容易产生混淆的概念笔者需要着重强调，首先是这时候进行内存分配的仅包括类变量，而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在Java堆中。
请注意，准备阶段并未执行任何 Java 代码。public static int value = 123;
那变量value在准备阶段过后的初始值为0而不是123，因为这时尚未开始执行任何Java方法，而把 value赋值为123的putstatic指令是程序被编译后，存放于类构造器()方法之中，所以把value赋值为123的动作要到类的初始化阶段才会被执行。
基本数据类型的零值

类加载—解析阶段

解析然后进入可选的解析符号引用阶段。也就是解析常量池，主要有以下四种：类或接口的解析、字段解析、类方法解析、接口方法解析。
简单的来说就是我们编写的代码中，当一个变量引用某个对象的时候，这个引用在 .class 文件中是以符号引用来存储的（相当于做了一个索引记录）。
在解析阶段就需要将其解析并链接为直接引用（相当于指向实际对象）。如果有了直接引用，那引用的目标必定在堆中存在。
加载一个 class 时, 需要加载所有的 super 类和 super 接口。

类加载—初始化阶段

进行准备阶段时，变量已经赋过一次系统要求的初始零值，而在初始化阶段，则会根据程序员通过程序编码制定的主观计划去初始化类变量和其他资源， JVM 规范明确规定, 必须在类的首次“主动使用”时才能执行类初始化。初始化的过程包括执行:【类构造器方法、 static 静态变量赋值语句、static 静态代码块】。
（1）.初始化阶段就是执行类构造器()方法的过程，。()并不是程序员在Java代码中直接编写的方法，它是Javac编译器的自动生成物，·()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}块）中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序决定的，静态语句块中只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块可以赋值，但是不能访问。
示例：

public class Test { 
    //静态代码的执行顺序按照出现的顺序决定
	static { 
	// 给变量复制可以正常编译通过，虽然此时还未定义变量i的类型 
	i = 0; 
	// 这句编译器会提示“非法向前引用” 
	System.out.print(i); 
	}
	//此时才定义i变量，但是给i=0却未报错
	static int i = 1; 
}

（2）.Java虚拟机会保证在子类的()方法执行前，父类的()方法已经执行完毕。因此在Java虚拟机中第一个被执行的()方法的类型肯定是java.lang.Object。

static class Parent {
	 public static int A = 1; 
	 static { 
		 A = 2; 
	 } 
 }
 static class Sub extends Parent { 
 	//执行该代码前，Parent类已经初始化完毕，A=2，所以此时B=2
 	public static int B = A; 
 }

（3）.同一个类加载器下，一个类型只会被初始化一次,Java虚拟机必须保证一个类的()方法在多线程环境中被正确地加锁同步，如果多个线程同时去初始化一个类，那么只会有其中一个线程去执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行完毕()方法。如果在一个类的()方法中有耗时很长的操作，那就可能造成多个进程阻塞。其他线程唤醒后则不会再次进入＜clinit＞()方法。同一个类加载器下，一个类型只会被初始化一次。

类加载器

类加载器虽然只用于实现类的加载动作，但它在Java程序中起到的作用却远超类加载阶段。对于任意一个类，都必须由加载它的类加载器和这个类本身一起共同确立其在Java虚拟机中的唯一性，每一个类加载器，都拥有一个独立的类名称空间。这句话可以表达得更通俗一些：比较两个类是否“相等”，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一个 Class文件，被同一个Java虚拟机加载，只要加载它们的类加载器不同，那这两个类就必定不相等。这里所指的“相等”，包括代表类的Class对象的equals()方法、isAssignableFrom()方法、isInstance() 方法的返回结果，也包括了使用instanceof关键字做对象所属关系判定等各种情况。如果没有注意到类加载器的影响，在某些情况下可能会产生具有迷惑性的结果。

三种自带类加载器

JVM自带的类加载器分为三种：

（1）.启动类加载器：负责加载JRE的核心类库，如jre目标下的rt.jar,charsets.jar等，
，是用原生 C++ 代码来实现的，并不继承自 java.lang.ClassLoader，获取为null
（2）.扩展类加载器：负责加载JRE扩展目录ext中JAR类包,码里直接获取它的父类加载器为 null（因为无法拿到启动类加载器）
（3）.系统类加载器：负责加载ClassPath路径下的类包,，在没有使用自定义类加载器情况下，用户自定义的类都由此加载器加载
（4）.用户自定义加载器：负责加载用户自定义路径下的类包

获取一个类的启动加载器
 //String类由启动类加载器加载，获取加载器为null,因为c++编写
 System.out.println(String.class.getClassLoader());
 //获取用户自定义的类的加载器，结果jdk.internal.loader.ClassLoaders$AppClassLoader
 System.out.println(JvmLoadDemo.class.getClassLoader().getClass().getName());

双亲委派机制

在这里插入图片描述当一个自定义类加载器需要加载一个类，比如 java.lang.String，它很懒，不会一上来就直接试图加载它，而是先委托自己的父加载器去加载，父加载器如果发现自己还有父加载器，会一直往前找，这样只要上级加载器，比如启动类加载器已经加载了某个类比如 java.lang.String，所有的子加载器都不需要自己加载了。如果几个类加载器都没有加载到指定名称的类，那么会抛出 ClassNotFountException 异常。

双亲委派机制伪代码：

protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { 
        // 首先，检查请求的类是否已经被加载过了 
        Class c = findLoadedClass(name); 
        if (c == null) { 
            try { 
                if (parent != null) { 
                    c = parent.loadClass(name, false); 
                } else { c = findBootstrapClassOrNull(name); 
                }
            } catch (ClassNotFoundException e) { 
                // 如果父类加载器抛出ClassNotFoundException 
                // 说明父类加载器无法完成加载请求 
            }
            if (c == null) { 
                // 在父类加载器无法加载时 
                // 再调用本身的findClass方法来进行类加载 
                c = findClass(name);
            } 
        }
        if (resolve) { 
            resolveClass(c); 
        }
}

双亲委派模式优势：
沙箱安全机制：自己写的String.class类不会被加载，这样便可以防止核心API库被随意篡改
避免类的重复加载：当父亲已经加载了该类时，就没有必要子ClassLoader再加载一次。

负责依赖机制

如果一个加载器在加载某个类的时候，发现这个类依赖于另外几个类或接口，也会去尝试加载这些依赖项。

缓存加载机制

为了提升加载效率，消除重复加载，一旦某个类被一个类加载器加载，那么它会缓存这个加载结果，不会重复加载。

细嗅蔷薇的大老虎

关注

0
点赞
踩
0

收藏

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

简介编写的java代码经过编译后变成.class文件，最终经过jvm的加载才能变成元数据区的class对象，进而执行我们的逻辑。类的生命周期和加载过程一个类在 JVM 里的生命周期有 7 个阶段，分别是加载（Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（Using）、卸载（Unloading），其中【验证、准备、解析】也叫连接。加载阶段...
复制链接

扫一扫