[TOC] 虚拟机把描述类的数据从Class文件**加载**到内存，并对数据进行**校验**、转换**解析**和**初始化**，最终成为被虚拟机直接使用的Java对象，这就是JVM的类加载机制。     Java天生的可动态扩展的语言特性就是依赖运行期的**动态加载**和**动态连接**实现的。 </br> ##     一：类的生命周期     类的生命周期包括7个部分：加载——验证——准备——解析——初始化——使用——卸载     其中，验证——准备——解析  称为连接阶段。除了解析外，其他阶段是顺序发生的，而解析可以与这些阶段交叉进行，因为Java支持动态绑定（晚期绑定），需要运行时才能确定具体类型。 ##     二：类的初始化触发     类的加载机制没有明确的触发条件，但是有5种情况下必须对类进行初始化，那么 加载——验证——准备 就必须在此之前完成了。     1：new、getstatic、putstatic、invokestatic这4个  字节码指令  时对类进行初始化（即：**实例化对象、读写静态对象、调用静态方法时，进行类的初始化**）；     2：使用反射机制对类进行调用时，进行类的初始化；     3：初始化一个类，其父类没有初始化时，先初始化其父类；     4：虚拟机启动时，初始化一个执行主类；     5：使用JDK1.7的**动态语言**支持时，如果MethodHandle实例的解析结果为REF\_getstatic、REF\_putstatic、REF\_invokestatic的方法句柄（即：读写静态对象或者调用静态方法），则初始化该句柄对应类；     一般，以上5种情况**最常见的是前三种：实例化对象、读写静态对象、调用静态方法、反射机制调用类、调用子类触发父类初始化**。 ##     三：类的加载过程     从用户角度来说，类（对象）的生命周期只需笼统理解为“加载——使用——卸载”即可，无需太过深入。所以，这里的类加载过程就是我们说的 加载——验证——准备——解析（非必须）——初始化  这五个使用前的阶段。 ###     1：加载        加载阶段，虚拟机需要完成三件事：**通过类名字获取类的二进制字节流——将字节流的内容转存到方法区——在内存中生成一个Class对象作为该类方法区数据的访问入口**。        其中，第一步：通过类名获取类的二进制字节流是通过类加载器来完成的。其加载过程使用“双亲委派模型”：        类加载器的层次结构为：         启动类加载器：加载系统环境变量下JAVA\_HOME/lib目录下的类库。        扩展类加载器：加载JAVA\_HOME/lib/ext目录下的类库。        应用程序类加载器（系统类加载器）：加载用户类路径Class\_Path指定的类库。（我们可以在使用第三方插件时，把jar包添加到ClassPath后就是使用了这个加载器）        自定义加载器：如果需要自定义加载时的规则（比如：指定类的字节流来源、动态加载时性能优化等），可以自己实现类加载器。        双亲委派模型是指：当一个类加载器收到类加载请求时，不会直接加载这个类，而是把这个加载请求委派给自己父加载器去完成。如果父加载器无法加载时，子加载器才会去尝试加载。        采用双亲委派模型的原因：避免同一个类被多个类加载器重复加载。 ###     2：验证        确保class文件的二进制字节流中包含的信息符号虚拟机要求，包括：文件格式验证、元数据验证（数据语义分析）、字节码验证（数据流语义合法性）、符号引用验证（符号引用的匹配性校验，确保解析能正确执行） ###     3：准备        为**类变量（静态变量）**在**方法区**分配内存，并设置**零值**。注意：这里是类变量，不是实例变量，实例变量是对象分配到**堆内存**时根据运行时动态生成的。 ###     4：解析        把常量池中的符号引用解析为直接引用：根据符号引用所作的描述，在内存中找到符合描述的目标并把目标指针指针返回。 --- 关于符号引用与直接引用，我们还是用一个实例来分析吧。看下面的 Java 代码： ``` package test; public class Test { public static void main(String[] args) { Sub sub = new Sub(); int a = 100; int d = sub.inc(a); } } class Sub { public int inc(int a) { return a + 2; } } ``` 编译后使用 javap 分析工具，会得到下面的 Class 文件内容： ``` Constant pool: #1 = Methodref #6.#15 // java/lang/Object."":()V #2 = Class #16 // test/Sub #3 = Methodref #2.#15 // test/Sub."":()V #4 = Methodref #2.#17 // test/Sub.inc:(I)I #5 = Class #18 // test/Test #6 = Class #19 // java/lang/Object #7 = Utf8 #8 = Utf8 ()V #9 = Utf8 Code #10 = Utf8 LineNumberTable #11 = Utf8 main #12 = Utf8 (\[Ljava/lang/String;)V #13 = Utf8 SourceFile #14 = Utf8 Test.java #15 = NameAndType #7:#8 // "":()V #16 = Utf8 test/Sub #17 = NameAndType #20:#21 // inc:(I)I #18 = Utf8 test/Test #19 = Utf8 java/lang/Object #20 = Utf8 inc #21 = Utf8 (I)I { public test.Test(); descriptor: ()V Code: stack=1, locals=1, args_size=1 0: aload_0 1: invokespecial #1 // Method java/lang/Object."<init>":()V 4: return public static void main(java.lang.String[]); descriptor: ([Ljava/lang/String;)V Code: stack=2, locals=4, args_size=1 0: new #2 // class test/Sub 3: dup 4: invokespecial #3 // Method test/Sub."<init>":()V 7: astore_1 8: bipush 100 10: istore_2 11: aload_1 12: iload_2 13: invokevirtual #4 // Method test/Sub.inc:(I)I 16: istore_3 17: return } ``` 因为篇幅有限，上面的内容只保留了常量池，和 Code 部分。下面我们主要对 inc 方法的调用来进行说明。 **符号引用 ** 在 main 方法的字节码中，调用 inc 方法的指令如下： ``` 13: invokevirtual #4 // Method test/Sub.inc:(I)I ``` invokevirtual 指令就是调用实例方法的指令，后面的操作数 4 是 Class 文件中常量池的下标，表示用来指定要调用的目标方法。我们再来看常量池在这个位置上的内容： ``` #4 = Methodref #2.#17 ``` 这是一个 Methodref 类型的数据，我们再来看看虚拟机规范中对该类型的说明： ``` CONSTANT_Methodref_info { u1 tag; u2 class_index; u2 name_and_type_index; } ``` 这实际上就是一种引用类型，tag 表示了常量池数据类型，这里固定是 10。class_index 表示了类的索引，name_and_type_index 表示了名称与类型的索引，这两个也都是常量池的下标。在 javap 的输出中，已经将对应的关系打印了出来，我们可以直接的观察到它都引用了哪些类型： ``` #4 = Methodref #2.#17 // test/Sub.inc:(I)I |--#2 = Class #16 // test/Sub | |--#16 = Utf8 test/Sub |--#17 = NameAndType #20:#21 // inc:(I)I | |--#20 = Utf8 inc | |--#21 = Utf8 (I)I ``` 这里我们将其表现为树的形式。可以看到，我们可以得到该方法所在的类，以及方法的名称和描述符。于是我们根据 invokevirtual 的操作数，找到了常量池中方法对应的 Methodref，进而找到了方法所在的类以及方法的名称和描述符，当然这些内容最终都是字符串形式。 实际上这就是一个符号引用的例子，符号引用也可以理解为像这样使用文字形式来描述引用关系。 **直接引用 ** 符号引用在上面说完了，我们知道符号引用大概就是文字形式表示的引用关系。但是在方法的执行中，只有这样一串字符串，有什么用呢？方法的本体在哪里？下面这就是直接引用的概念了，这里我用自己目前的理解总结一下，直接引用就是通过对符号引用进行解析，来获得真正的函数入口地址，也就是在运行的内存区域找到该方法字节码的起始位置，从而真正的调用方法。 那么将符号引用解析为直接引用的过程是什么样的呢？我这个小渣渣目前也给不出确定的答案，在 JVM里的符号引用如何存储？ 里，RednaxelaFX 大大给出了一个 Sun JDK 1.0.2 的实现；在 自己动手写Java虚拟机 中，作者给出了一种用 Go 的简单实现，下面这里就来看一下这个简单一些的实现。在 HotSpot VM 中的实现肯定要复杂得多，这里还是以大致的学习了解为主，以后如果有时间有精力，再去研究一下 OpenJDK 中 HotSpot VM 的实现。 不过不管是哪种实现，肯定要先读取 Class 文件，然后将其以某种格式保存在内存中，类的数据会记录在某个结构体内，方法的数据也会记录在另外的结构体中，然后将结构体之间相互组合、关联起来。比如，我们用下面的形式来表达 Class 的数据在内存中的保存形式： ``` type Class struct { accessFlags uint16 // 访问控制 name string // 类名 superClassName string // 父类名 interfaceNames []string // 接口名列表 constantPool *ConstantPool // 该类对应的常量池 fields []*Field // 字段列表 methods []*Method // 方法列表 loader *ClassLoader // 加载该类的类加载器 superClass *Class // 父类结构体的引用 interfaces []*Class // 各个接口结构体的引用 instanceSlotCount uint // 类中的实例变量数量 staticSlotCount uint // 类中的静态变量数量 staticVars Slots // 类中的静态变量的引用列表 initStarted bool // 类是否被初始化 } ``` 类似的，常量池中的方法引用，也要有类似的结构来表示： ``` type MethodRef struct { cp *ConstantPool // 常量池 className string // 所在的类名 class *Class // 所在的类的结构体引用 name string // 方法名 descriptor string // 描述符 method *Method // 方法数据的引用 } ``` 回到上面符号解析的例子。当遇到 invokevirtual 指令时，根据后面的操作数，可以去常量池中指定位置取到方法引用的结构体。实际上这个结构体中已经包含了上面看到的各种符号引用，最下面的 method 就是真正的方法数据。类加载到内存中时，method 的值为空，当方法第一次调用时，会根据符号引用，找到方法的直接引用，并将值赋予 method。从而后面再次调用该方法时，只需要返回 method 即可。下面我们看方法的解析过程： ``` func (self *MethodRef) resolveMethodRef() { c := self.ResolvedClass() method := lookupMethod(c, self.name, self.descriptor) if method == nil { panic("java.lang.NoSuchMethodError") } self.method = method } ``` 这里面省略了验证的部分，包括检查解析后的方法是否为空、检查当前类是否可以访问该方法，等等。首先我们看到，第一步是找到方法对应的类： ``` func (self *SymRef) ResolvedClass() *Class { if self.class == nil { d := self.cp.class c := d.loader.LoadClass(self.className) self.class = c } return self.class } ``` 在 MethodRef 结构体中包含对应 class 的引用，如果 class 不为空，则可以直接返回；否则会根据类名，使用当前类的类加载器去尝试加载这个类。最后将加载好的类引用赋给 MethodRef.class。找到了方法所在的类，下一步就是从类中找到这个方法，也就是方法数据在内存中的地址，对应上面的 lookupMethod 方法。查找时，会遍历类中的方法列表，这块在类加载的过程中已经完成，下面是方法数据的结构体： ``` type Method struct { accessFlags uint16 name string descriptor string class *Class maxStack uint maxLocals uint code []byte argSlotCount uint } ``` 这个其实就和 Class 文件中的 Code 属性类似，这里面省略了异常和其他的一些信息。类加载过程中，会将各个方法的 Code 属性按照上面的结构保存在内存中，然后将类中所有方法的地址列表保存在 Class 结构体中。当在 Class 结构体中查找指定方法时，只需要遍历方法列表，然后比较方法名和描述符即可： ``` for c := class; c != nil; c = c.superClass { for _, method := range c.methods { if method.name == name && method.descriptor == descriptor { return method } } } ``` 可以看到，查找方法会从当前方法查找，如果找不到，会继续从父类中查找。除此以外，还会从实现的接口列表中查找，代码中省略了这部分，还有一些判断的条件。 最终，如果成功找到了指定方法，就会将方法数据的地址赋给 MethodRef.method，后面对该方法的调用只需要直接返回 MethodRef.method 即可。 ###     5：初始化        真正开始执行Java程序代码，该步执行方法根据代码赋值语句，对**类变量和其他资源**  进行初始化赋值。        方法：编译器自动收集类中所有  类变量的赋值语句和静态语句合并而成，收集的顺序是在程序代码出现的顺序。所以，静态语句中只能访问到定义在静态语句块之前的变量，在其之后的变量可以赋值（相当于新建并赋值了）但不可以访问（因为还没出现）。        注：由此步我们就可以得知，我们在分析向上转型的例子时的程序代码的运行顺序了：父类静态内容——子类静态内容——父类构造——子类构造——子类方法 。     在经历了上面5步“加载”阶段后，才真正地可以使用class对象或者使用实例对象。使用过后，不再需要用到该类的class对象或者实例对象时，就会把类卸载掉（发生在方法区的垃圾回收：无用类的卸载）。 ##     四：对象的生命周期      对象是由类创建出来的，所以对象的生命周期就是包含在类的生命周期中：      类加载（5步）——创建类的实例对象——使用对象——对象回收——类卸载