JVM底层之类加载

最新推荐文章于 2024-07-12 18:54:40 发布

@milo

最新推荐文章于 2024-07-12 18:54:40 发布

阅读量546

点赞数 2

分类专栏： JVM Java 类加载文章标签： java jvm

本文链接：https://blog.csdn.net/m0_37838198/article/details/110671279

版权

Java 同时被 3 个专栏收录

6 篇文章 0 订阅

订阅专栏

JVM

5 篇文章 0 订阅

订阅专栏

类加载

1 篇文章 0 订阅

订阅专栏

1、Klass模型

首先明确class 和klass的区别： class是Java类（Java代码），而klass是Java类在JVM的存在形式（c++代码）

Java的每个类，在JVM中，都有一个对应的Klass类实例与之对应，存储类的元信息如：常量池、属性信息、方法信息……

从继承关系上也能看出来，类的元信息是存储在原空间的（instanceKlass），对象是存储在堆区的（InstanceMirrorKlass）

类加载器将.class文件加载进系统，将.class文件解析，那么生成的是什么？类的元信息在JVM中是如何存储的呢？

instanceKlass

普通的Java类通过类加载后在JVM中对应的是 instanceKlass 类(Java类，非数组)的实例，再来说下它的三个字类

InstanceMirrorKlass：用于表示java.lang.Class，Java代码中获取到的Class对象，实际上就是这个C++类的实例，存储在堆区，学名镜像类
InstanceRefKlass：用于表示java/lang/ref/Reference类的子类（引用强软弱虚）
InstanceClassLoaderKlass：用于遍历某个加载器加载的类

可以获取进程的ID后通过HSDB工具查看具体的详情，下面举例子环节

public class Test_1 {
    public static void main(String[] args) {
        while (true);
    }
}

可以看到在JVM中就是一个InstanceKlass，java mirror就是class对象

ArrayKlass

Java中的数组不是静态数据类型，是动态数据类型，即是运行期生成的，Java数组的元信息用 ArrayKlass 的子类来表示：

TypeArrayKlass：用于表示基本类型的数组（基本类型的数组在JVM中的存在形式）
ObjArrayKlass：用于表示引用类型的数组（引用类型的数组在JVM中的存在形式）

来演示一下，继续举例子(IDE装插件jclasslib查看字节码)

public class Test_1 {
    public static void main(String[] args) {
        int[] ints = new int[1];
        Test_1[] test_1s = new Test_1[1];
        while (true);
    }
}

编译后查看字节码，如下图，关于字节码，可以看我另一个博客jvm字节码对照表

newarray 创建一个指定原始类型（如int, float, char…）的数组，并将其引用值压入栈顶
anewarray 创建一个引用型（如类，接口，数组）的数组，并将其引用值压入栈顶

HSDB查看线程堆栈

int[] ints = new int[1];

Test_1[] test_1s = new Test_1[1];

2、类的加载过程

啥也不说先上图，类的生命周期是由7个阶段组成，但是类的加载说的是前5个阶段

加载

1、通过类的全限定名获取存储该类的class文件（没有指明必须从哪获取）

2、解析成运行时数据，即instanceKlass实例，存放在方法区

3、在堆区生成该类的Class对象，即instanceMirrorKlass实例

程序随便你怎么写，随便你用什么语言，只要能达到这个效果即可，就是说你可以改写openjdk源码，你写的程序能达到这三个效果即可

那么问题来了，类是何时加载的?

主动使用时

1、new、getstatic、putstatic、invokestatic

2、反射

3、初始化一个类的子类会去加载其父类

4、启动类（main函数所在类）

5、当使用jdk1.7动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getstatic,REF_putstatic,REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行初始化，则需要先出触发其初始化

预加载：包装类、String、Thread

从哪加载?

因为没有指明必须从哪获取class文件，脑洞大开的工程师们开发了这些

1、从压缩包中读取，如jar、war

2、从网络中获取，如Web Applet

3、动态生成，如动态代理、CGLIB

4、由其他文件生成，如JSP

5、从数据库读取

6、从加密文件中读取

JVM加载类是懒加载模式lazy loading

比如根加载器bootstrap加载rt.jar中的类不会全部被加载，只是预加载，比如String，Thread，Interger，使用的时候才会加载，针对上面五种情况结合面试输出情况具体看一下，示例统一放到下面第四部分（面试部分）。

验证

1、文件格式验证

2、元数据验证

3、字节码验证

4、符号引用验证

具体的理论可以在周志明的《深入理解Java虚拟机》中看。

准备

为静态变量分配内存、赋初值

实例变量是在创建对象的时候完成赋值的，没有赋初值一说

如果被final修饰，在编译的时候会给属性添加ConstantValue属性，准备阶段直接完成赋值，即没有赋初值这一步

public class Test_1 {
    public static final int a = 10;
    public static int b = 10;
    public static void main(String[] args) {
    //        System.out.printf(Test_1_B.str);
        int[] ints = new int[1];
        Test_1[] test_1s = new Test_1[1];
        while (true);
    }
}

解析

将常量池中的符号引用(间接引用)转为直接引用

间接引用：指向运行时常量池的引用
直接引用：内存地址

解析后的信息存储在ConstantPoolCache类实例中

1、类或接口的解析

2、字段解析

3、方法解析

4、接口方法解析

可以通过javap -verbose查看一个引用的转化过程，可以看到常量池中，指向了#32，在#32中是个字符串，这就是符号引用（指向运行时常量池的引用）

当程序运行以后类已经被解析了，已经有真实的内存地址了，这时就是直接引用了

何时解析

思路：

1、加载阶段解析常量池时

2、用的时候

openjdk是第二种思路，在执行特定的字节码指令之前进行解析：

anewarray、checkcast、getfield、getstatic、instanceof、invokedynamic、invokeinterface、invokespecial、invokestatic、invokevirtual、ldc、ldc_w、ldc2_w、multianewarray、new、putfield

初始化

执行静态代码块，完成静态变量的赋值

静态字段、静态代码段，字节码层面会生成clinit方法

方法中语句的先后顺序与代码的编写顺序相关，即代码顺序跟定义的顺序是保持一致的

public class Test_1 {
    public static int a = 10;
    public static int b = 10;
    public static void main(String[] args) {
    //        System.out.printf(Test_1_B.str);
        int[] ints = new int[1];
        Test_1[] test_1s = new Test_1[1];
        while (true);
    }
}

注意这里和指令重排不是一回事，指令重排序是运行时。

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

通过HSDB对下面代码分析

public class Test_1 {
    public static void main(String[] args) {
        System.out.printf(Test_1_B.str);
        while (true);
    }
}

class Test_1_A {
    public static String str = "A str";

    static {
        System.out.println("A Static Block");
    }
}

class Test_1_B extends Test_1_A {
    static {
        System.out.println("B Static Block");
    }
}

Test_1_A类结构

可以看到静态属性是存储在instanceMirrorKlass（镜像类中的），而不是instanceKlass

Test_1_B类结构

可以看到是没有str的，所以说str只存在于父类

总结

我们可以有两种猜想：

1、先去Test_1_B的镜像类中去取，如果有直接返回；如果没有，会沿着继承链将请求往上抛。很明显，这种算法的性能随继承链的death而上升，算法复杂度为O(n)

2、借助另外的数据结构实现，使用K-V的格式存储，查询性能为O(1)

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

\openjdk\hotspot\src\share\vm\interpreter\bytecodeInterpreter.cpp

CASE(_getstatic):
        {
          u2 index;
          // 从代码中可以看出，可以看到获取数据的时候不是从常量池获取数据而是直接取的Entry
          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);
          }
……

ConstantPoolCacheEntry: ConstantPoolCacheEntry是在ConstantPoolCache对象后面，代码中返回结果 return (ConstantPoolCacheEntry*)((address)this + in_bytes(base_offset()));

ConstantPoolCacheEntry在哪呢？在ConstantPoolCache对象后面，看代码

\openjdk\hotspot\src\share\vm\oops\cpCache.hpp

ConstantPoolCacheEntry* base() const           { 
  // 这个公式的意思是ConstantPoolCache对象的地址加上ConstantPoolCache对象的内存大小
  return (ConstantPoolCacheEntry*)((address)this + in_bytes(base_offset()));
}

4、面试相关

判断程序运行结果

public class Test_21 {

    public static void main(String[] args) {
        Test_21_A obj = Test_21_A.getInstance();

        System.out.println(Test_21_A.val1);
        System.out.println(Test_21_A.val2);
    }
}

class Test_21_A {

    public static int val1;
    public static int val2 = 1;

    public static Test_21_A instance = new Test_21_A();

     Test_21_A() {
        val1++;
        val2++;
    }

    public static Test_21_A getInstance() {
        return instance;
    }
}
/**
 * 程序初始化的时候
 * val1 = 0
 * val2 = 1
 *
 * 然后执行++
 * val1 = 0+1
 * val2 = 1+1 
 * 结果：
 *      1
 *      2
 */

改变一下代码顺序


public class Test_21 {

    public static void main(String[] args) {
        Test_21_A obj = Test_21_A.getInstance();

        System.out.println(Test_21_A.val1);
        System.out.println(Test_21_A.val2);
    }
}

class Test_21_A {

    public static int val1;

    public static Test_21_A instance = new Test_21_A();

    Test_21_A() {
        val1++;
        val2++;
    }

    public static int val2 = 1;
    public static Test_21_A getInstance() {
        return instance;
    }
}
/**
 * 这时会存在一个覆盖的情况
 * 程序初始化的时候
 * val1 = 0
 * val2 = 0
 *
 * 然后执行++后结果是1，1
 * val1 = 0+1
 * val2 = 1+1 
 然后val2执行静态代码初始化赋值1
 * 结果：
 *      1
 *      1
 */

类加载过程示例

public class Test_1 {
    public static void main(String[] args) {
        System.out.printf(Test_1_B.str);
    }
}

class Test_1_A {
    public static String str = "A str";

    static {
        System.out.println("A Static Block");
    }
}

class Test_1_B extends Test_1_A {
    static {
        System.out.println("B Static Block");
    }
}

/**
 * 类只有使用的时候才会加载（懒加载措施）
 * 结果：
 * A Static Block
 * A str
 */

public class Test_1 {
    public static void main(String[] args) {
        System.out.printf(new Test_1_B().str);
    }
}

class Test_1_A {
    public String str = "A str";

    static {
        System.out.println("A Static Block");
    }
}

class Test_1_B extends Test_1_A {
    static {
        System.out.println("B Static Block");
    }
}

/**
 * 结果：
 * A Static Block
 * B Static Block
 * A str
 */

初始化一个类的子类会去加载其父类

public class Test_1 {
    public static void main(String[] args) {
        System.out.printf(new Test_1_B().str);
    }
}

class Test_1_A {
    static {
        System.out.println("A Static Block");
    }
}

class Test_1_B extends Test_1_A {
    public String str = "A str";
    static {
        System.out.println("B Static Block");
    }
}

/**
 * 将变量放到子类中，主动使用子类，其实是间接在主动使用父类
 * 结果：
 * A Static Block
 * B Static Block
 * A str
 */

public class Test_2 {

    public static void main(String[] args) {
        System.out.printf(Test_2_B.str);
    }
}

class Test_2_A {
    static {
        System.out.println("A Static Block");
    }
}

class Test_2_B extends Test_2_A {
    public static String str = "B str";

    static {
        System.out.println("B Static Block");
    }
}

/**
 * 将静态变量放到子类中
 * 结果：
 * A Static Block
 * B Static Block
 * B str
 */

public class Test_4 {

    public static void main(String[] args) {
        Test_4 arrs[] = new Test_4[1];
    }
}

class Test_4_A {
    static {
        System.out.println("Test_4_A Static Block");
    }
}

/**
 * 这只是定义了一个数据类型
 * 结果：不输出
 *   
 */

public class Test_6 {

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

class Test_6_A {

    public static final String str = "A Str";

    static {
        System.out.println("Test_6_A Static Block");
    }
}

/**
 * 注意final，看字节码即可理解 将常量str写入了Test_6的常量池中
 * 结果：
 *   A str
 */

public class Test_7 {

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

class Test_7_A {
    public static final String uuid = UUID.randomUUID().toString();

    static {
        System.out.println("Test_7_A Static Block");
    }
}

/**
 * 此时这里的UUID.randomUUID().toString();是动态生成的，JVM在运行的时候没有办法写入Test_7的常量池，需要动态生成，就会设计到    Test_7_A的主动使用。继续看字节码会发现UUID.randomUUID().toString()是代码段，而不是一个常量。
 * 结果：
 *   Test_7_A Static Block
 *   919ee7bc-3bc3-42a7-bd40-ee43fecec594
 */

反射的情况

public class Test_8 {

    static {
        System.out.println("Test_8 Static Block");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> clazz = Class.forName("com.luban.ziya.classload.Test_1_A");
    }
}

/**
 * 此时这里
 * 结果：
 *   Test_8 Static Block
 *   A Static Block
 */