JVM底层之类加载

klass模型

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

看下klass模型类的继承结构

从继承关系上也能看出来，类的元信息是存储在原空间的

类加载器将.class文件加载进系统

将.class文件解析，生成的就是InstanceKlass

MetaspaceObj

	JDK8以后类的元信息都是存储在类的元空间里的就是**MetaspaceObj** 是所有类的顶层父类。

InstanceKlass

	InstanceKlass就是我们写的Java类(非数组)，InstanceKlass就是类加载器把Java文件存储到内存中经过解析后生成的。  

	InstanceKlass包含的一些属性：注解 _annotations、__method..

普通的Java类在JVM中对应的是instanceKlass类的实例，再来说下它的三个子类

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

总结： 类加载器将.class文件加载进系统，将.class文件解析，生成的类的元信息以InstanceKlass存储在JVM中

ArrayKlass

ArrayKlass就是用来存储数组的元信息。

Java的数组

静态数据类型 JVM中内置的八种数据类型

动态数组类型运行时动态生成

证明： 为什么Java中的数组是动态生成的？

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

运行结果：

结果生成一个newarray 顾名思义就是生成一个数组嘛。

我们查看字节码手册也是可以看的到的如下信息：

指令码	助记符	说明
0xbc	newarray	创建一个指定原始类型（如int, float, char…）的数组，并将其引用值压入栈顶

我们再测试一个引用类型的数组：

public class Test_1 {
public static void main(String[] args) {
//        System.out.printf(Test_1_B.str);
int[] arr = new int[1];

Test_1[] arr2 =  new Test_1[1];
while (true);
}
}

输出：

可以看出输出的为 anewarray ，字节码文档解释如下：

指令码	助记符	说明
0xbd	anewarray	创建一个引用型（如类，接口，数组）的数组，并将其引用值压入栈顶

也就是基本数据类型，在JVM中的存在形式是以TypeArrayKlass存在的。以上得知什么？简单来说就是，

anewarray 也就是引用类型的数组，在JVM中的存在形式是以ObjArrayKlass存在的。

类加载的过程

类加载由7个步骤完成，看图

加载

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

全限定名： 包名+类名

程序随便你怎么写，随便你用什么语言，只要能达到这个效果即可

就是说你可以改写openjdk源码，你写的程序能达到这三个效果即可

何时加载

主动使用时

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

预加载：包装类、String、Thread

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

从压缩包中读取，如jar、war
从网络中获取，如Web Applet
动态生成，如动态代理、CGLIB
由其他文件生成，如JSP
从数据库读取
从加密文件中读取

验证

文件格式验证
元数据验证
字节码验证
符号引用验证

准备

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

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

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

验证：

public static final int a = 10;
public static int b = 10;

输出：

解析

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

直接引用就是指向内存地址

间接引用指向运行时常量池

每个类都有一个常量池

class常量池（静态的） HSDB常量池（动态的）

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

类或接口的解析
字段解析
方法解析
接口方法解析

何时解析

思路：

加载阶段解析常量池时
用的时候

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

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

初始化

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

定义一个static静态代码块，JVM底层会生成一个clinit，生成clinit方法
代码顺序和定义顺序保持一致的。

来一个小问题代码如下：

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

输出：

why？

很明显：

val1 = 0 val2 = 1

执行代码块之后各自+1，

所以输出结果为 1 2

再看一个题：

public class Test_22 {
public static void main(String[] args) {
Test_22_A obj = Test_22_A.getInstance();
System.out.println(Test_22_A.val1);
System.out.println(Test_22_A.val2);
}
}
class Test_22_A {
public static int val1;
public static Test_22_A instance = new Test_22_A();
Test_22_A() {
val1++;
val2++;
}
public static int val2 = 1;
public static Test_22_A getInstance() {
return instance;
}
}

输出：

分析：

结合上一题这个代码会出来一个覆盖的情况，所以输出为 1 1

类加载细节

JVM加载类是懒加载模式

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

输出：

证明：

类只有在使用的时候才会加载

public class Test_1 {
public static void main(String[] args) {
System.out.printf(new Test_1_B().str);
while (true);
}
}
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");
}
  public String str = "A str";

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

输出：

证明：

主动使用子类，父类也会加载。

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修饰它定义的是常量，JVM将常量str写入了Test_6的常量池中

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是动态生成的所以JVM没办法把UUID放入到Test_7的常量池中，所以会加载，它生成的是动态代码段

public class Test_8 {
static {
System.out.println("Test_8 Static Block");
}
public static void main(String[] args) throws ClassNotFoundException {
Class

输出：

这就是一个反射，读取静态属性时，反射也会读取

读取静态字段的实现原理

public class Test_1 {
public static void main(String[] args) {
System.out.printf(new Test_1_B().str);
while (true);
}
}
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");
}
}

思路：

1. 先去Test_1_B的镜像类中去取，如果有直接返回，如果没有，会沿着继承链将请求往上抛。这种算法的性能随着继承链的death而上升，算法复杂度为0（0）；

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

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

！！！！撒花！！！！