Kclass模型和JVM类加载过程详解

最新推荐文章于 2024-01-26 17:30:18 发布
最新推荐文章于 2024-01-26 17:30:18 发布
阅读量813 收藏 6
点赞数
分类专栏： # jvm 文章标签： java
原文链接：https://blog.csdn.net/qq_43631716/article/details/115611129
版权

Kclass模型和JVM类加载过程详解_沮丧的南瓜-CSDN博客_kclass

一、Klass模型

Java的每个类，在JVM中，都有一个对应的Klass类实例与之对应，存储类的元信息如：常量池、属性信息、方法信息…… 看下klass模型类的继承结构 在这里插入图片描述 从继承关系上也能看出来，类的元信息是存储在原空间的； 普通的Java类在JVM中对应的是instanceKlass类的实例，再来说下它的三个字类

  1. InstanceMirrorKlass：用于表示java.lang.Class，Java代码中获取到的Class对象，实际上就是这个C++类的实例，存储在堆区，学名镜像类

  2. InstanceRefKlass：用于表示java/lang/ref/Reference类的子类

  3. InstanceClassLoaderKlass：用于遍历某个加载器加载的类 Java中的数组不是静态数据类型，是动态数据类型，即是运行期生成的，Java数组的元信息用ArrayKlass的子类来表示：

  4. TypeArrayKlass：用于表示基本类型的数组

  5. ObjArrayKlass：用于表示引用类型的数组

二、类加载过程

在这里插入图片描述

1、加载

1、通过类的全限定名获取存储该类的class文件（没有指明必须从哪里获取）； 2、解析运行时数据区，即instanceKlass实例，存放在方法区； 3、在堆区生成该类的Class对象，即instanceMirrorKlass对象。

1.2、何时加载

1、new、getstatic、putstatic、invokestatic 2、反射 3、初始化一个类的子类会去加载其父类 4、启动类（main函数所在类） 5、当使用jdk1.7动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getstatic,REF_putstatic,REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行初始化，则需要先出触发其初始化（可以忽略）

预加载：包装类、String、Thread

1.3、从哪里加载 因为没有指明必须从哪获取class文件，脑洞大开的工程师们开发了这些 1、从压缩包中读取，如jar、war 2、从网络中获取，如Web Applet 3、动态生成，如动态代理、CGLIB 4、由其他文件生成，如JSP 5、从数据库读取 6、从加密文件中读取

2、验证

1、文件格式验证 2、元数据验证 3、字节码验证 4、符号引用验证

3、准备

为静态变量分配内存、赋初值 实例变量是在创建对象的时候完成赋值的，没有赋初值一说 在这里插入图片描述 如果被final修饰 ，在编译的时候会给属性添加ConstantValue属性，准备阶段直接完成赋值，即没有赋初值这一步。

4、解析

间接引用：指向运行时产量池的引用，符号引用，比如#32这个符号对应的是某个类的全限定名的字符串而已； 直接引用：类的内存地址，不再指向常量池

将常量池中的符号引用转为直接引用 解析后的信息存储在ConstantPoolCache类实例中 1、类或接口的解析 2、字段解析 3、方法解析 4、接口方法解析

我们使用javap -verbose Test_1.class 来查看静态常量池（查看的是class文件的）：

public class Test_1 {
    public static void main(String[] args) {
        System.out.println("test_1");
    }
}
​
Constant pool:
   #1 = Methodref          #6.#20         // java/lang/Object."<init>":()V
   #2 = Fieldref           #21.#22        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #23            // test_1
   #4 = Methodref          #24.#25        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #26            // com/jihu/test/jvm/Test_1
   #6 = Class              #27            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lcom/jihu/test/jvm/Test_1;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               SourceFile
  #19 = Utf8               Test_1.java
  #20 = NameAndType        #7:#8          // "<init>":()V
  #21 = Class              #28            // java/lang/System
  #22 = NameAndType        #29:#30        // out:Ljava/io/PrintStream;
  #23 = Utf8               test_1
  #24 = Class              #31            // java/io/PrintStream
  #25 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #26 = Utf8               com/jihu/test/jvm/Test_1
  #27 = Utf8               java/lang/Object
  #28 = Utf8               java/lang/System
  #29 = Utf8               out
  #30 = Utf8               Ljava/io/PrintStream;
  #31 = Utf8               java/io/PrintStream
  #32 = Utf8               println
  #33 = Utf8               (Ljava/lang/String;)V
​
1234567891011121314151617181920212223242526272829303132333435363738394041

可以看到这里的class只是一个符号引用。

然后我们启动并阻塞代码，使用HSDB来查看动态常量池：

public class Test_1 {
    public static void main(String[] args) {
        System.out.println("test_1");
        while (true);
    }
}
​
1234567

在这里插入图片描述 当运行代码后，此时类已经被解析了。此时可以看到，类的引用是真实的内存地址引用，不再指向常量池。

每一个类都拥有一个常量池！！！

5、初始化

类初始阶段，JVM底层会加锁，解决并发问题！

执行静态代码块，完成静态变量的赋值 静态字段、静态代码段，字节码层面会生成clinit方法 方法中语句的先后顺序与代码的编写顺序相关

定义一个static属性，JVM会自动生成一个clinit。 在这里插入图片描述 生成的clinit方法，代码顺序跟定义的顺序保持一致。 在这里插入图片描述 大家猜一下下面代码的运行结果： 在这里插入图片描述 结果是：1,1。 这里和定义的顺序有关系，存在值的覆盖。开始默认值为0， val2++之后为1，然后又设置为1.

三、JVM加载类模式是懒加载 Lazy loading

我们都知道rt.jar是有根加载器bootStrap加载的，事实上也只会加载一部分类，不是全部的类，这叫做预加载。预先加载的类是一些常用类，比如String，Thread, Integer等。

我们来看下面程序的运行结果： 在这里插入图片描述在这里插入图片描述 类是在使用的时候加载，Test_1_B必须要要实例化对象，因为是静态字段，也没有任何调用，所以不需要初始化类。

我们再来看下面的代码： 在这里插入图片描述在这里插入图片描述 此时需要实例化类对象才能访问到属性，所以会初始化类。

我们再来看下面的代码： 在这里插入图片描述在这里插入图片描述 加载一个类的时候会优先加载父类！

再来看下面的代码： 在这里插入图片描述在这里插入图片描述 再看看下面这个，你还能猜对的吗？ 在这里插入图片描述在这里插入图片描述 此时只是定义了数据类型，并没有实例化对象。

再来看一个final的： 在这里插入图片描述在这里插入图片描述

final修饰的静态变量在准备阶段已经赋好了初始值，所以获取的时候不需要加载类。 final String str被写入了类Test_6_A的类常量池中，我们使用javap -verbose来查看class的静态常量池： 在这里插入图片描述

我们再来看一个UUID的： 在这里插入图片描述在这里插入图片描述 是不是有点好奇？Why? 因为UUID.randomUUID()是动态运行的，JVM没办法确定该值，无法将其写入到类的常量池中！

在这里插入图片描述在这里插入图片描述 反射也会加载类。

在这里插入图片描述在这里插入图片描述 这里可能我们会有些迷惑，为什么子类对静态属性的操作没有生效呢？

我们要明确一点，JVM首先会判断类是否加载，只有当一个类加载后才会进行初始化操作！上面的代码中不需要加载子类，自然就不会初始化子类，即不会执行子类的静态代码块。

四、读取静态变量的底层实现

在这里插入图片描述

可以看到，在类Test1_A中是存在静态属性的，JDK6之后，静态属性是存在于镜像类instanceMirrorKlass中的;JDK6之前是存储在instanceKlass中的。

我们再来看看Test1_B中是否存在该静态属性：

在这里插入图片描述

此时我们发现没有找到Test1_B，因为在代码中我们调用的是：System.out.println(Test1_A.str); ，此时值加载了类Test_A这个父类，不需要加载Test1_B子类，所以没有在加载的类列表中找到该类。

我们修改代码： 在这里插入图片描述 此时是通过子类调用父类的属性，我们可以看到父类和子类都已经被加载了，这也验证了JVM类加载是懒加载，按需加载。

我们来看子类的instanceMirrowKlass中是否存在属性str: 在这里插入图片描述 从结果来看，该属性是不存在子类的镜像类中的。

可以猜得到，通过子类Test1_B访问父类Test1_A的静态字段有两种实现方式： 1、先去Test_1_B的镜像类中去取，如果有直接返回；如果没有，会沿着继承链将请求往上抛。很明显，这种算法的性能随继承链的death而上升，算法复杂度为O(n) 2、借助另外的数据结构实现，使用K-V的格式存储，查询性能为O(1)

Hotspot就是使用的第二种方式，借助另外的数据结构ConstantPoolCache，常量池类ConstantPool中有个属性_cache指向了这个结构。每一条数据对应一个类ConstantPoolCacheEntry。

ConstancePoolCache主要用于存储某些字节码指令所需的解析（resolve）好的常量项，例如给[get|put]static、[get|put]field、invoke[static|special|virtual|interface|dynamic]等指令对应的常量池项用。

ConstantPoolCacheEntry在哪呢？在ConstantPoolCache对象后面，看代码 \openjdk\hotspot\src\share\vm\oops\cpCache.hpp

ConstantPoolCacheEntry* base() const           { 
  return (ConstantPoolCacheEntry*)((address)this + in_bytes(base_offset()));
}
123

这个公式的意思是ConstantPoolCache对象的地址加上ConstantPoolCache对象的内存大小

ConstantPoolCache

常量池缓存是为常量池预留的运行时数据结构。保存所有字段访问和调用字节码的解释器运行时信息。缓存是在类被积极使用之前创建和初始化的。每个缓存项在解析时被填充

如何读取 \openjdk\hotspot\src\share\vm\interpreter\bytecodeInterpreter.cpp

CASE(_getstatic):
        {
          u2 index;
          ConstantPoolCacheEntry* cache;
          index = Bytes::get_native_u2(pc+1);
​
          // QQQ Need to make this as inlined as possible. Probably need to
          // split all the bytecode cases out so c++ compiler has a chance
          // for constant prop to fold everything possible away.
​
          cache = cp->entry_at(index);
          if (!cache->is_resolved((Bytecodes::Code)opcode)) {
            CALL_VM(InterpreterRuntime::resolve_get_put(THREAD, (Bytecodes::Code)opcode),
                    handle_exception);
            cache = cp->entry_at(index);
          }
……
1234567891011121314151617

从代码中可以看出，是直接去获取ConstantPoolCacheEntry.

yygr
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
klass对象模型.png
07-12
javav oop模型 思维导图..............................................
JVM类加载机制详解
08-31
JVM类加载机制是Java虚拟机运行时加载类的核心过程，它负责将.java编译后的字节码文件（.class）转换为内存中的类实例。本文详细阐述了这个机制，包括其工作流程、特点以及如何自定义类加载器。 首先，我们来看一下...
JVM - java对象模型 Oop-Kclass 模型
面朝大海，春暖花开
06-08 1120
JVM - java对象模型 Oop-Kclass 模型 Oop-Kclass 模型 Oop-Kclass 模型组成 OOP 英文全程是Ordinary Object Pointe，即普通对象指针，看起来像个指针实际上是藏在指针里的对象，表示对象的实例信息 Klass 元数据和方法信息(类的继承，成员变量，静态变量，成员方法等等)，用来描述 Java。是Java类的在C++中的表示形式，用来描述Java类的信息 mark_word 存储结构 mark_word中存储结构 锁状态 对象的 hashCo
(2.1.1.3) JVM内容：对象的生命周期与OOP-Klass模型
JAVA成长之路
03-19 956
目录 一、对象的创建 1.1 判断对象对应的类是否加载、链接、初始化 1.2 为对象分配内存 1.3 处理并发安全问题 1.4 初始化分配到的内存空间 1.5 设置对象的对象头 1.6 执行init方法进行初始化 二、对象的堆内存布局 三、HotSpot的对象模型 3.1 对象、引用与类的关联 四、对象的生命周期 参考文献 一、对象的创建 对象的创建通常是通过new一个...
klass模型
Guofucheng0720的博客
12-17 409
Java的每个类，在JVM中，都有一个对应的Klass类实例与之对应，存储类的元信息如：常量池、属性信息、方法信息…… 看下klass模型类的继承结构 从继承关系上也能看出来，类的元信息是存储在原空间的 普通的Java类在JVM中对应的是instanceKlass类的实例，再来说下它的三个字类 InstanceMirrorKlass：用于表示java.lang.Class，Java代码中获取到的Class对象，实际上就是这个C++类的实例，存储在堆区，学名镜像类【Class对象】 **InstanceRe
JVM的类加载过程以及双亲委派模型详解
08-25
JVM类加载过程和双亲委派模型详解 JVM类加载过程是将.class文件加载到JVM内存中，然后转化为Class对象的过程。类加载器是根据指定全限定名称将class文件加载到JVM内存，然后再转化为Class对象。 类加载器分类： *...
java类加载过程详解.doc
10-27
Java 类加载过程是Java虚拟机（JVM）在运行时动态加载类的机制，它涉及类的生命周期中的几个关键步骤，包括装载、连接、初始化和卸载。下面将详细阐述这些过程。 1. 装载 装载阶段是类加载的起始点，主要分为三个...
深入理解JVM之类加载机制详解
08-25
"深入理解JVM之类加载机制详解" 本文主要介绍了深入理解JVM之类加载机制的知识点，结合实例形式详细分析了类加载机制原理、过程及相关操作注意事项。 1. 类加载机制概述 类加载机制是Java虚拟机把描述类的数据从...
JVM类加载过程.pptx
05-07
JVM类加载过程 JVM（Java Virtual Machine）是Java语言的核心组件之一，它是Java语言的可移植性和跨平台性的基础。JVM主要组成部分包括类加载子系统、执行引擎、本地方法接口和运行时数据区。 类加载子系统是JVM的...
KClass与函数引用详解
webor2006的博客
09-24 324
继续学习Kotlin反射相关的东东。 KClass： 在上一次是通过类来获取它的KClass对象： 那如果是一个对象呢？与这个对象对应的类的KClass对象又是如何获取的呢？像Java也是一样有相关机制的，下面看一下： 其实使用跟用类是一样的，那结果是啥呢？运行一下： 这样就打出来了具体类型了，由于是咱们自己定义的类，所以其KClass和Class是同一个，跟上一次用的系统类输出是不一样的...
KClass初探
最新发布
圆师傅的博客
01-26 398
在 Kotlin 中，KClass 是一种特殊的类型，用于表示 Kotlin 类的类引用。KClass 提供了一些有用的函数和属性，以便在运行时对类进行操作和访问。KClass 是 Kotlin 反射 API 的一部分，可以通过::class来获取一个类的 KClass 实例。
【深入kotlin】 - KClass 特性深入研究
kmyhy的专栏
02-23 728
KClass 特性深入研究 kotlin 反射 vs. Java 反射 其实可以通过 KClass 获取属性的 java 特性，比如获得 get/set 方法和 field 的引用： class T(val x:Int) fun main(args: Array<String>) { println(T::x) // 打印：val com.kotlin.T.x: kotlin.Int println(T::x.javaGetter) // 打印：public final int com.
JVM1--oop-klass模型
chenjiexong的博客
08-07 313
Metadata–>元数据，用于描述数据的数据。或者说是用于提供某种资源有关信息的数据结构。 简单的理解，元数据和java中的实体类类似，抽象出一类东西所具有的的特征，利用这些特征区分同一类东西的不同属性。 类加载器将.class文件加载进系统，将.class文件解析，生成的是什么？类的元信息在JVM中是如何存储的？ 也就是说oop-klass模型，就是jvm用于存储类加载器加载、解析.class文件的“实体类”。 InstanceKlass–>表示的是java类(非数组，数组的)，表示java
JVM之字节码——分析class文件（一）_kenvifire-ChinaUnix博客
weixin_34413357的博客
09-16 82
二、手动分析class文件 上面大致讲解了一下class文件的结构，这里，我们拿一个class文件做一个简单的分析，来验证上面的说法。 先看看一个简单的类 点击(此处)折叠或打开public class Hello{ private int test;public int test(){return test;}} 编译之后的class文件十六进制结果如下所示，可以用...
JVM oop-klass模型
@Bean
03-24 336
JVM oop-klass模型
Klass模型与类加载的详细机制
计算机王的博客
02-15 1650
klass模型是jvm中的数据类型 这个数据类型表示的是一个java类 java语言是在jvm中运行而jvm是不认识java代码的我们使用javac编译的class文件jvm是不认识的 所以有一个类加载的动作 这个动作就是把class字节码拼装成一个klass类型 这个klass类型是c++中的一个类 klass里面有java类中的所有信息比如它的属性 方法 修饰符等成为类的元信息 这些信息放在元空间中 通过下面的klass类的继承关系图可以看出 metaspace中文意思就是元空间 meatadata
Class文件格式总结
昨夜星辰的博客
03-29 6016
到此， 所有关于class文件格式的重要内容都已经讲解完了， 不敢说面面俱到， 但是敢说大部分重要的内容都包含在内了。前前后后用了9篇博客来专门讲解class文件结构， 为什么花那么多的时间和精力来介绍class文件呢？ 简而言之，因为它很重要。在前面的文章中， 也讲到过为什么对于理解Java体系结构来说， 理解class文件的格式至关重要。 其实这篇短文也不是对class文件格式细节上的总结，
具体讲讲JVM类加载中的解析过程
08-26
### 回答1： JVM（Java Virtual Machine）是Java程序的执行环境。当你运行一个Java程序时，它首先被编译成字节码，然后JVM将字节码解释成机器码并执行。 JVM的类加载过程可以分为以下几个步骤： 1. 加载（Loading）：加载指的是将.class文件读入内存，并为之创建一个java.lang.Class对象。类加载器会负责从文件系统、JAR文件或网络中加载类的字节码数据。 2. 链接（Linking）：链接分为三个阶段，分别是验证（Verification）、准备（Preparation）和解析（Resolution）。 * 验证：验证字节码是否符合JVM规范，并且不会危害JVM的安全。如果验证失败，则会抛出java.lang.VerifyError异常。 * 准备：为类的静态变量分配内存，并将其初始化为默认值（0、null等）。 * 解析：将类、接口、字段和方法的符号引用解析为实际引用。这个过程可能需要在运行时进行。 3. 初始化（Initialization）：在类加载过程中，初始化是最后一步。在这个阶段，静态变量被初始化，静态块被执行。如果初始化一个类时发生异常，则会抛出java.lang.ExceptionInInitializerError异常。 JVM的类加载器有以下几种： 1. 启动类加载器（Bootstrap ClassLoader）：它是最顶层的类加载器，负责加载JVM的核心类库，如java.lang和java.util等。 2. 扩展类加载器（Extension ClassLoader）：它加载Java平台扩展库的类。默认情况下，它从$JAVA_HOME/jre/lib/ext目录加载类。 3. 系统类加载器（System ClassLoader）：也称应用程序类加载器，它加载应用程序类路径上的类。 4. 用户自定义类加载器：开发人员可以继承java.lang.ClassLoader类，以实现自己的类加载器。 总之，JVM的类加载过程是Java程序运行的重要部分，它可以确保Java程序的正确执行。 ### 回答2： JVM（Java虚拟机）类加载过程，是指JVM将字节码文件加载到内存，并转化为可以被JVM执行的可执行代码的过程。其中，解析是类加载过程的一个重要步骤。 解析是JVM对类或接口的常量池中的符号引用进行直接引用的过程。在解析阶段，JVM将符号引用转换成直接引用，使得类或接口可以直接被调用和执行。解析包括以下几个步骤： 1. 类或接口的符号引用：在类或接口的常量池中，使用符号引用表示对其他类或接口的引用，符号引用包括类的全限定名、方法的签名以及字段的描述符等。 2. 类或接口的符号解析：JVM将符号引用转换成直接引用的过程。直接引用是一个指向类、方法、字段在内存中的地址，JVM可以根据直接引用直接访问类、方法或字段。 3. 类的初始化：在类的解析过程中，JVM还会执行类的初始化。类的初始化包括为静态变量赋值、执行静态代码块等。类的初始化是在解析过程的最后阶段执行的，确保类在被解析之后可以正常执行。 需要注意的是，类或接口的解析并不一定发生在加载过程的一开始，JVM会根据需要进行解析。同时，在解析过程中，如果发生了符号引用无法解析的错误，JVM会抛出NoClassDefFoundError异常。 总之，JVM类加载过程中的解析是将类或接口的符号引用转换成直接引用的过程，使得程序可以直接访问和执行类、方法以及字段。解析是类加载过程的关键步骤之一，保证了类的正确加载和正常执行。 ### 回答3： JVM的类加载过程包括：加载、验证、准备、解析和初始化五个阶段。其中，解析是指将常量池中的符号引用替换为直接引用的过程。 1. 加载阶段：JVM通过类加载器将字节码文件加载到内存中。加载阶段包括三个步骤：通过类的全限定名找到定义类的二进制数据文件，将二进制数据读入内存并创建一个Class对象，并在内存中生成一个代表该类的Class对象。 2. 验证阶段：JVM对字节码进行验证，确保字节码文件符合JVM规范，并且没有安全方面的问题，如是否包含不合法或危险的代码。 3. 准备阶段：JVM为类的静态字段分配内存并设置默认初始值。这些值保存在方法区的静态变量区域中，方法区是JVM中的一块内存区域，用于存储类的结构信息。 4. 解析阶段：在解析阶段，JVM将类、接口、字段和方法的符号引用替换为直接引用。符号引用是一组描述被引用的目标的符号，而直接引用是直接指向目标的指针、句柄或偏移量。在解析阶段，JVM将符号引用转换为直接引用，以便后续的执行中可以直接访问到目标。 5. 初始化阶段：在初始化阶段，JVM会对类的静态变量赋予正确的初始值，并执行静态代码块。静态代码块中的代码主要用于初始化类的静态变量和执行静态初始化块。只有在这个阶段，类的实例才会被真正地创建。 总结来说，JVM的类加载过程中，解析阶段的主要目的是将常量池中的符号引用转换为直接引用，以便后续的执行中可以直接访问到目标。这个过程在类加载的第三个阶段准备之后进行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值