【学习笔记】深入理解java虚拟机之类的探索

类文件结构

相关概念：

• 全限定名

  • 形如org/fenixsoft/clazz/TestClass，称为全限定名,通常以;结尾

• 简单名称

  • 没有类型和参数修饰的方法或者字段名称

• 描述符

  • 用来描述字段的类型，方法的参数列表（数量、类型和数量）和返回值
  • 基本数据类型以及无返回值的void都使用一个大写字符来表示;对象类型使用L+对象全限定名表示
  • 数组使用前置[表示，如java.lang.String[][]会被记录为[[Ljava/lang/String;
  • 用描述符描述方法时，先参数列表后返回值的顺序进行描述，参数列表按照参数的严格顺序放在一组小括号“()”之内

  标识字符	含义
  B	byte
  C	char
  D	double
  F	float
  I	int
  J	long
  S	short
  Z	boolean
  V	void
  L	对象类型，如Ljava/lang/Object;

Class类文件的结构

Class文件是一组以8个字节为基础单位的二进制流，数据按照严格顺序紧凑排列在文件中，中间没有任何分隔符。当遇到需要占用8个字节以上空间的数据时，会按照高位在前的方式分割成若干个8个字节进行存储。这种顺序称为“Big-Endian”，具体顺序是指按高位字节在地址最低位，最低字节在地址最高位来存储数据。

Class文件格式采用一种伪结构来存储数据，这种伪结构中只有两种数据类型，“无符号数"和"表”。

• 无符号数
  • 属于基本类型，以u1、u2、u4、u8分别表示1个，2个，4个，8个字节的无符号数
  • 可以用来描述数字、索引引用、数据值或者按照UTF-8编码构成的字符串值。
• 表
  • 表是由多个无符号数或其他表作为数据项构成的符合数据结构
  • 所有表通常都已"_info"结尾。表用于描述有层级关系的符合结构的数据。
  • 无论是无符号数还是表，当需要描述同一类型但数量不确定的多个数据时，经常会使用一个前置的容量计数器加若干个连续的数据项的形式，称这一系列的某一类型的数据为某一类型的"集合"。

魔数和Class文件的版本

魔数

每个Class文件的头四个字节称为魔数

• 唯一作用
  
  确认该文件是否为一个可被虚拟机接受的Class文件。

• Class文件的魔数

  0xCAFEBABE

版本号

Class文件紧接着魔数的四个字节存储的是Class文件的版本号，5、6位是次版本号，7、8位是主版本号

• java版本号是从45开始
• 小版本是从0到65535
• 每个java大版本 主版本号向上+1
• 高版本JDK向下兼容以前的版本，不支持以后的版本（应《java虚拟机规范》要求）
• 如JDK 1.1版本支持版本号为45.0 ~ 45.65535的Class文件，不支持46.0以上版本的Class文件
  ！[java class文件格式](/Java Class文件的格式.png)

常量池

• 紧接着主次版本号之后
• 被比喻为Class文件的资源仓库
• Class类结构中与其他项目关联最多的数据
• 占用Class文件空间最大的数据项目之一
• Class文件中第一个出现的表结构

常量池容量

由于常量池数据不固定，常量池入口(紧接着主次版本号之后的字节)放置了一项u2类型的数据，代表常量池容量计数值（constant_pool_count）

• 计数从1开始，如常量池计数为22，则表示常量池里有21项常量。
• 这样做的目的在于，如果后面某些指向常量池的索引值的数据在特定情况下需要表达“不引用任何一个常量池项目”的含义，可以把索引值设置为0来表示

常量池存储内容

• 字面量（Literal）

  文本字符串，被声明为final的常量值等。

• 符号引用（Symbolic References）

  • 被模块导出或者开发的包（Package）
  • 类和接口的全限定名（Fully Qualified Name）
  • 字段的名称和描述符（Descriptor）
  • 方法的名称和描述符
  • 方法句柄和方法类型（Method handle，Method Type，Invoke Dynamic）
  • 动态调用点和动态常量（Dynamically-ComputedCallSite、Dynamically-ComputedConstant）

常量结构

• 每一个常量都是一个表
• 第一位是u1类型的标志位（tag）后面根据常量类型不同，有不同的表结构
• 常量表的类型个数（截止JDK13）：17种 = 11(初始) + 4（为了更好支持动态语言调用） + 2（为了支持Java模块化系统，CONSTANT_Module_info和CONSTANT_Package_info）

常量	项目	类型	描述
CONSTANT_utf8_info	tag	u1	值为1
	length	u2	UTF-8编码的字符串占用的字节数
	bytes	u1	长度为length的UTF-8编码的字符串
CONSTANT_Integer_info	tag	u1	值为3
	bytes	u4	按照高位在前存储的int值
CONSTANT_Float_info	tag	u1	值为4
	bytes	u4	按照高位在前存储的float值
CONSTANT_Long_info	tag	u1	值为5
	bytes	u8	按照高位在前存储的long值
CONSTANT_Double_info	tag	u1	值为6
	bytes	u8	按照高位在前存储的double值
CONSTANT_Class_info	tag	u1	值为7
	index	u2	指向全限制名常量项的索引
CONSTANT_String_info	tag	u1	值为8
	index	u2	指向字符串字面量的索引
CONSTANT_Fieldref_info	tag	u1	值为9
	index	u2	指向声明字段的类或接口描述符CONSTANT_Class_info的索引项
	index	u2	指向字段描述符CONSTANT_NameAndType的索引项
CONSTANT_Methodref_info	tag	u1	值为10
	index	u2	指向声明方法的类描述符CONSTANT_Class_info的索引项
	index	u2	指向名称及类型描述符CONSTANT_NameAndType的索引项
CONSTANT_InterfaceMethodref_info	tag	u1	值为11
	index	u2	指向声明方法的接口描述符CONSTANT_Class_info的索引项
	index	u2	指向名称及类型描述符CONSTANT_NameAndType的索引项
CONSTANT_NameAndType_info	tag	u1	值为12
	index	u2	指向该字段或方法名称常量项的索引
	index	u2	指向该字段或方法描述符常量项的索引
CONSTANT_MethodHandle_info	tag	u1	值为15
	reference_kind	u1	值必须在[1,9]之间，决定了方法句柄的类型。方法句柄类型的值表示方法句柄的字节码行为
	reference_index	u2	值必须是对常量池的有效索引
CONSTANT_MethodType_info	tag	u1	值为16
	description_index	u2	值必须是对常量池的有效索引, 索引处必须是CONSTANT_Utf8_info结构
CONSTANT_Dynamic_info	tag	u1	值为17
	bootstrap_method_attr_index	u2	值必须是对当前Class文件中引导方法表的bootstrap_methods[]数组的有效索引
	name_and_type_index	u2	值必须是对常量池的有效索引，索引处必须是CONSTANT_NameAndType_info结构，表示方法名和方法的描述符
CONSTANT_InvokeDynamic_info	tag	u1	值为18
	bootstrap_method_attr_index	u2	值必须是对当前Class文件中引导方法表的bootstrap_methods[]数组的有效索引
	name_and_type_index	u2	值必须是对常量池的有效索引，索引处必须是CONSTANT_NameAndType_info结构，表示方法名和方法的描述符
CONSTANT_Module_info	tag	u1	值为19
	name_index	u2	值必须是对常量池的有效索引，索引处必须是CONSTANT_Utf8_info结构，表示模块名称
CONSTANT_Package_info	tag	u1	值为10
	name_index	u2	值必须是对常量池的有效索引，索引处必须是CONSTANT_Utf8_info结构，表示包名称

访问标志

常量池结束之后紧接着2个字节代表访问标志(access_flags), 标志用于识别一些类或者接口层次的访问信息

标志名称	标志值	含义
ACC_PUBLIC	0x0001	是否是public
ACC_FINAL	0x0010	是否被声明为final,只有类可以设置
ACC_SUPER	0x0020	是否允许使用invokespecial字节码指令的新语义，JDK1.0.2之后编译出来的类都必须是真
ACC_INTERFACE	0x0200	标志这是一个接口
ACC_ABSTRACT	0x0400	是否是abstract类型，对于接口和抽象类来说为真，其他为假
ACC_SYNTHETIC	0x1000	标志这个类并非用户代码生成
ACC_ANNOTATION	0x2000	标志这是一个注解
ACC_ENUM	0x4000	标志这是一个枚举
ACC_MODULE	0x8000	标志这是一个模块

类索引、父类索引以及接口索引集合

类索引、父类索引和接口索引集合按照顺序排列在访问标志之后

• 类索引
  • u2类型的数据
  • 用于确定这个类的全限定名
  • u2类型的索引值指向类型为CONSTANT_Class_info的类描述常量，通过CONSTANT_Class_info中的索引值找到一个定义在CONSTANT_Utf8_info类型中的全限定名字符串
• 父类索引
  • u2类型的数据
  • 用于确定这个类的父类全限定名
  • 由于java的单继承，父类索引只能有一个
  • 除了java.lang.Object，所有的java类的父类索引都不为0
  • 索引值查找关系于类索引相同
• 接口索引集合
  • 一组u2类型数据的集合
  • 用于描述这个类实现了哪些接口
  • 接口在集合中的顺序依照implements关键字后的接口顺序（如果当前类是接口，则依照extends后的顺序）
  • 入口的第一个u2类型的数据为接口计数器，后面为接口对应的索引表
    • 如果没有实现任何接口，计数器为0，后面不再占用任何字节

字段表集合（field_info）

用于描述接口或类中声明的变量，包括类变量，实例变量，不包括方法中声明的局部变量

• 字段表结构

类型	名称	数量
u2	access_flags	1
u2	name_index	1
u2	description_index	1
u2	attributes_count	1
attributes_info	attributes	attributes_count

字段修饰符放在access_flags中，与类中的访问标志acces
_flags类似，都是u2类型的数据

标志位和含义如下表

标志名称	标志值	含义
ACC_PUBLIC	0x0001	字段是否public
ACC_PRIVATE	0x0002	字段是否private
ACC_PROTECTED	0x0004	字段是否protected
ACC_STATIC	0x0008	字段是否static
ACC_FINAL	0x0010	字段是否final
ACC_VOLATILE	0x0040	字段是否volatile
ACC_TRANSIENT	0x0080	字段是否transient
ACC_SYNTHETIC	0x1000	字段是否由编译器自动生成
ACC_ENUM	0x4000	字段是否enum

ACC_PUBLIC、ACC_PRIVATE、ACC_PROTECTED只能三选一
ACC_FINAL、ACC_VOLATILE不能同时选择
接口之中的字段必须有ACC_PUBLIC、ACC_STATIC、ACC_FINAL标志

name_index和descriptor_index

对常量池的引用，分别表示字段的简单名称和方法的描述符

字段中包括的修饰符

• 字段作用域（public、private、protected）
• 实例变量还是类变量（static）
• 可变性（final）
• 并发可见性（volatile修饰符，是否强制从主内存读写）
• 可否被序列化（transient）
• 字段数据类型（基本类型、对象、数组）
• 字段名称

字段表集合中不会列出父类或者父接口中的字段，但是有可能出现原java代码中不存在的字段，如内部类会自动添加指向外部类的字段。

方法表集合

方法表与字段表接口完全一致，只不过访问标志和属性表集合的可选项中有区别

表结构见字段表

访问标志
volatile和transient关键字不能修饰方法，而synchronized、native、strictfp和abstract关键字可以修饰方法，所以方法表对应的访问标志有所区别，具体如下：

标志名称	标志值	含义
ACC_PUBLIC	0x0001	是否public
ACC_PRIVATE	0x0002	是否private
ACC_PROTECTED	0x0004	是否protected
ACC_STATIC	0x0008	是否static
ACC_FINAL	0x0010	是否final
ACC_SYNCHRONIZED	0x0020	是否synchronized
ACC_BRIDGE	0x0040	是否由编译器产生的桥接方法
ACC_VARARGS	0x0080	是否接受不定参数
ACC_NATIVE	0x0100	是否native
ACC_ABSTRACT	0x0400	是否abstract
ACC_STRICT	0x0800	是否strictfp
ACC_SYBTHETIC	0x1000	是否由编译器自动产生

如果父类方法没有在子类中重写，方法表集合中就不会出现，有可能出现有编译器自动添加的方法，如类构造器()和实例构造器()

java重载，除了与原方法具有相同的简单名称之外，还要求必须拥有一个与原方法不同的特征签名。

• 特征签名
  • java代码层面
    
    只包含方法名称，参数顺序和参数类型
  • 字节码层面
    
    还包括方法返回值和受查异常表

属性表集合

• Class文件、字段表、方法表都可以携带自己的属性表集合，以描述某些场景专有的信息
• 与Class文件中其他的数据项目要求严格的顺序、长度和内容不同，属性表集合的限制稍微宽松一些，不再要求各个属性表具有严格顺序

列出常用的属性：

属性名称	使用位置	含义
Code	方法表	java代码编译成的字节码指令
ConstantValue	字段表	由final定义的常量值
Deprecated	类、方法表、字段表	被声明为Deprecated的方法和字段
Exceptions	方法表	方法抛出的异常列表
EnclosingMethod	类文件	仅当一个类为局部类或匿名类时才拥有这个属性，用于标示这个类所在的外围方法
InnerClasses	类文件	内部类列表
LineNumberTable	Code属性	java代码行号与字节码指令的对应关系
LocalVariableTable	Code属性	方法的局部变量表
LocalVariableTypeTable	类	使用特征签名代替描述符，是为了引入泛型语法之后能描述泛型参数化类型
SourseFile	类文件	记录源文件名称
SourceDebugExtension	类文件	用于存储额外的调试信息

Code属性

方法体中的代码经过javac编译器处理最终变成字节码指令存储在Code属性内。
Code属性出现在方法表的属性集合之中，但并非所有的方法表都必须存在这个属性，譬如接口或者抽象类中的方法就不存在Code属性

字节码指令

• Java虚拟机的指令由一个字节长度的、代表着某种特定操作含义的数字（称为操作码，Opcode）以及跟随其后的零至多个代表此操作所需的参数（称为操作数，Operand）构成
• 由于Java虚拟机采用面向操作数栈而不是面向寄存器的架构，所以大多数指令都不包含操作数，只有一个操作码，指令参数都存放在操作数栈中
• 由于限制了Java虚拟机操作码的长度为一个字节（即0～255），这意味着指令集的操作码总数不能够超过256条
• 由于Class文件格式放弃了编译后代码的操作数长度对齐，这就意味着虚拟机在处理那些超过一个字节的数据时，不得不在运行时从字节中重建出具体数据的结构

要将一个16位长度的无符号整数使用两个无符号字节存储起来（假设将它们命名为byte1和byte2）它们的值应该是：(byte1<<8)|byte2，
解释执行字节码时将损失一些性能, 但这样做的优势也同样明显：放弃了操作数长度对齐,可以省略掉大量的填充和间隔符号

字节码指令流基本上都是单字节对齐的，只有“tableswitch”和“lookupswitch”两条指令例外，由于它们的操作数比较特殊，是以4字节为界划分开的，所以这两条指令也需要预留出相应的空位填充来实现对齐

不考虑异常处理的话，那Java虚拟机的解释器可以使用下面这段伪代码作为最基本的执行模型来理解

do {
    自动计算PC寄存器的值加1;
    根据PC寄存器指示的位置，从字节码流中取出操作码;
    if (字节码存在操作数) 从字节码流中取出操作数;
    执行操作码所定义的操作;
} while(字节码流长度>0);

字节码与数据类型

• 在Java虚拟机的指令集中，大多数指令都包含其操作所对应的数据类型信息
  • 对于大部分与数据类型相关的字节码指令，它们的操作码助记符中都有特殊的字符来表明专门为哪种数据类型服务
    • i代表对int类型的数据操作
    • l代表long
    • s代表short
    • b代表byte
    • c代表char
    • f代表float
    • d代表double
    • a代表reference
  • 有一些指令的助记符中没有明确指明操作类型的字母
    • arraylength指令
      
      它没有代表数据类型的特殊字符，但操作数永远只能是一个数组类型的对象
  • 无条件跳转指令goto则是与数据类型无关的指令之一
• Java虚拟机的操作码长度只有一字节。如果每一种与数据类型相关的指令都支持Java虚拟机所有运行时数据类型的话，那么指令的数量恐怕就会超出一字节所能表示的数量范围了。并非每种数据类型和每一种操作都有对应的指令。有一些单独的指令可以在必要的时候用来将一些不支持的类型转换为可被支持的类型
• 大部分指令都没有支持整数类型byte、char和short，甚至没有任何指令支持boolean类型。编译器会在编译期或运行期将byte和short类型的数据带符号扩展（Sign-Extend）为相应的int类型数据，将boolean和char类型数据零位扩展（Zero-Extend）为相应的int类型数据

加载、存储指令

用于将数据在栈帧中的局部变量表和操作数栈之间来回传输

• 将一个局部变量加载到操作栈：iload、iload_、lload、lload_、fload、fload_、dload、dload_、aload、aload_
• 将一个数值从操作数栈存储到局部变量表：istore、istore_、lstore、lstore_、fstore、fstore_、dstore、dstore_、astore、astore_
• 将一个常量加载到操作数栈：bipush、sipush、ldc、ldc_w、ldc2_w、aconst_null、iconst_m1、iconst_、lconst_、fconst_、dconst_
• 扩充局部变量表的访问索引的指令：wide

有一部分是以尖括号结尾的（例如iload_），这些指令助记符实际上代表了一组指令。如iload_，它代表了iload_0、iload_1、iload_2和iload_3这几条指令

运算指令

用于对两个操作数栈上的值进行某种特定运算，并把结果重新存入到操作栈顶

• 大体上运算指令可以分为两种
  • 对整型数据进行运算的指令
  • 对浮点型数据进行运算的指令
• 不存在直接支持byte、short、char和boolean类型的算术指令，对于上述几种数据的运算，应使用操作int类型的指令代替
• 加法指令：iadd、ladd、fadd、dadd
• 减法指令：isub、lsub、fsub、dsub
• 乘法指令：imul、lmul、fmul、dmul
• 除法指令：idiv、ldiv、fdiv、ddiv
• 求余指令：irem、lrem、frem、drem
• 取反指令：ineg、lneg、fneg、dneg
• 位移指令：ishl、ishr、iushr、lshl、lshr、lushr
• 按位或指令：ior、lor
• 按位与指令：iand、land
• 按位异或指令：ixor、lxor
• 局部变量自增指令：iinc
• 比较指令：dcmpg、dcmpl、fcmpg、fcmpl、lcmp
• 其实《Java虚拟机规范》中并没有明确定义过整型数据溢出具体会得到什么计算结果，仅规定了在处理整型数据时，只有除法指令（idiv和ldiv）以及求余指令（irem和lrem）中当出现除数为零时会导致虚拟机抛出ArithmeticException异常，其余任何整型数运算场景都不应该抛出运行时异常
• Java虚拟机必须完全支持IEEE754中定义的“非正规浮点数值”（DenormalizedFloating-PointNumber）和“逐级下溢”（GradualUnderflow）的运算规则

类型转换指令

• Java虚拟机直接支持宽化类型转换,即小范围类型向大范围类型的安全转换
  • int类型到long、float或者double类型
  • long类型到float、double类型
  • float类型到double类型
• 处理窄化类型转换时，就必须显式地使用转换指令来完成, 转换指令包括i2b、i2c、i2s、l2i、f2i、f2l、d2i、d2l和d2f.窄化类型转换可能会导致转换结果产生不同的正负号、不同的数量级的情况，转换过程很可能会导致数值的精度丢失
• 在将int或long类型窄化转换为整数类型T的时候，转换过程仅仅是简单丢弃除最低位N字节以外的内容，N是类型T的数据类型长度，这将可能导致转换结果与输入值有不同的正负号。

对象创建与访问指令

• 虽然类实例和数组都是对象，但Java虚拟机对类实例和数组的创建与操作使用了不同的字节码指令
• 创建类实例的指令 new
• 创建数组的指令：newarray、anewarray、multianewarray
• 访问类字段（static字段，或者称为类变量）和实例字段（非static字段，或者称为实例变量）的指令：getfield、putfield、getstatic、putstatic
• 把一个数组元素加载到操作数栈的指令：baload、caload、saload、iaload、laload、faload、daload、aaload
• 将一个操作数栈的值储存到数组元素中的指令：bastore、castore、sastore、iastore、fastore、dastore、aastore
• 取数组长度的指令：arraylength
• 检查类实例类型的指令：instanceof、checkcast

操作数栈管理指令

如同操作一个普通数据结构中的堆栈那样，Java虚拟机提供了一些用于直接操作操作数栈的指令，包括：

• 将操作数栈的栈顶一个或两个元素出栈：pop、pop2
• 复制栈顶一个或两个数值并将复制值或双份的复制值重新压入栈顶：dup、dup2、dup_x1、dup2_x1、dup_x2、dup2_x2
• 将栈最顶端的两个数值互换：swap

控制转移指令

控制转移指令可以让Java虚拟机有条件或无条件地从指定位置指令（而不是控制转移指令）的下一条指令继续执行程序，从概念模型上理解，可以认为控制指令就是在有条件或无条件地修改PC寄存器的值.

• 条件分支：ifeq、iflt、ifle、ifne、ifgt、ifge、ifnull、ifnonnull、if_icmpeq、if_icmpne、if_icmplt、if_icmpgt、if_icmple、if_icmpge、if_acmpeq和if_acmpne
• 复合条件分支：tableswitch、lookupswitch
• 无条件分支：goto、goto_w、jsr、jsr_w、ret

对于boolean类型、byte类型、char类型和short类型的条件分支比较操作，都使用int类型的比较指令来完成
对于long类型、float类型和double类型的条件分支比较操作，则会先执行相应类型的比较运算指令（dcmpg、dcmpl、fcmpg、fcmpl、lcmp），运算指令会返回一个整型值到操作数栈中，随后再执行int类型的条件分支比较操作来完成整个分支跳转

方法调用和返回指令

• invokevirtual指令

  用于调用对象的实例方法，根据对象的实际类型进行分派（虚方法分派），这也是Java语言中最常见的方法分派方式

• invokeinterface指令

  用于调用接口方法，它会在运行时搜索一个实现了这个接口方法的对象，找出适合的方法进行调用。

• invokespecial指令

  用于调用一些需要特殊处理的实例方法，包括实例初始化方法、私有方法和父类方法。

• invokestatic指令

  用于调用类静态方法（static方法）

• invokedynamic指令

  用于在运行时动态解析出调用点限定符所引用的方法。并执行该方法。前面四条调用指令的分派逻辑都固化在Java虚拟机内部，用户无法改变，而invokedynamic指令的分派逻辑是由用户所设定的引导方法决定的

异常处理指令

• 在Java程序中显式抛出异常的操作（throw语句）都由athrow指令来实现
• 除了用throw语句显式抛出异常的情况之外，《Java虚拟机规范》还规定了许多运行时异常会在其他Java虚拟机指令检测到异常状况时自动抛出

例如整数运算中，当除数为零时，虚拟机会在idiv或ldiv指令中抛出ArithmeticException异常

• 在Java虚拟机中，处理异常（catch语句）不是由字节码指令来实现的（很久之前曾经使用jsr和ret指令来实现，现在已经不用了），而是采用异常表来完成

同步指令

Java虚拟机可以支持方法级的同步和方法内部一段指令序列的同步，这两种同步结构都是使用管程（Monitor，更常见的是直接将它称为“锁”）来实现的

• 方法级的同步是隐式的，无须通过字节码指令来控制，它实现在方法调用和返回操作之中
  • 虚拟机可以从方法常量池中的方法表结构中的ACC_SYNCHRONIZED访问标志得知一个方法是否被声明为同步方法。
  • 当方法调用时，调用指令将会检查方法的ACC_SYNCHRONIZED访问标志是否被设置，如果设置了，执行线程就要求先成功持有管程，然后才能执行方法，最后当方法完成（无论是正常完成还是非正常完成）时释放管程。
  • 在方法执行期间，执行线程持有了管程，其他任何线程都无法再获取到同一个管程。
  • 如果一个同步方法执行期间抛出了异常，并且在方法内部无法处理此异常，那这个同步方法所持有的管程将在异常抛到同步方法边界之外时自动释放
• 同步一段指令集序列通常是由Java语言中的synchronized语句块来表示的，Java虚拟机的指令集中有monitorenter和monitorexit两条指令来支持synchronized关键字的语义，正确实现synchronized关键字需要Javac编译器与Java虚拟机两者共同协作支持

编译器必须确保无论方法通过何种方式完成，方法中调用过的每条monitorenter指令都必须有其对应的monitorexit指令，而无论这个方法是正常结束还是异常结束

HotSpot虚拟机对象探秘

对象的创建过程

• 去检查这个指令的参数是否能在常量池中定位到一个类的符号引用，并且检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有，那必须先执行相应的类加载过程
• 在类加载检查通过后，接下来虚拟机将为新生对象分配内存。对象所需内存的大小在类加载完成后便可完全确定。为对象分配空间的任务实际上便等同于把一块确定大小的内存块从Java堆中划分出来
  • Java堆中内存是绝对规整的，所有被使用过的内存都被放在一边，空闲的内存被放在另一边，中间放着一个指针作为分界点的指示器，那所分配内存就仅仅是把那个指针向空闲空间方向挪动一段与对象大小相等的距离，这种分配方式称为“指针碰撞”（BumpThePointer）。
  • 如果Java堆中的内存并不是规整的，已被使用的内存和空闲的内存相互交错在一起，那就没有办法简单地进行指针碰撞了，虚拟机就必须维护一个列表，记录上哪些内存块是可用的，在分配的时候从列表中找到一块足够大的空间划分给对象实例，并更新列表上的记录，这种分配方式称为“空闲列表”（FreeList）

选择哪种分配方式由Java堆是否规整决定，而Java堆是否规整又由所采用的垃圾收集器是否带有空间压缩整理（Compact）的能力决定。因此，当使用Serial、ParNew等带压缩整理过程的收集器时，系统采用的分配算法是指针碰撞，既简单又高效；而当使用CMS这种基于清除（Sweep）算法的收集器时，理论上就只能采用较为复杂的空闲列表来分配内存

• 如何在分配内存过程保证线程安全

  • 一种是对分配内存空间的动作进行同步处理——实际上虚拟机是采用CAS配上失败重试的方式保证更新操作的原子性；
  • 另外一种是把内存分配的动作按照线程划分在不同的空间之中进行，即每个线程在Java堆中预先分配一小块内存，称为本地线程分配缓冲（ThreadLocalAllocationBuffer，TLAB），哪个线程要分配内存，就在哪个线程的本地缓冲区中分配，只有本地缓冲区用完了，分配新的缓存区时才需要同步锁定。虚拟机是否使用TLAB，可以通过-XX：+/-UseTLAB参数来设定。

• 虚拟机必须将分配到的内存空间（但不包括对象头）都初始化为零值，如果使用了TLAB的话，这一项工作也可以提前至TLAB分配时顺便进行

  这步操作保证了对象的实例字段在Java代码中可以不赋初始值就直接使用，使程序能访问到这些字段的数据类型所对应的零值

• Java虚拟机还要对对象进行必要的设置

  • 例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码（实际上对象的哈希码会延后到真正调用Object::hashCode()方法时才计算）、对象的GC分代年龄等信息。
  • 这些信息存放在对象的对象头（ObjectHeader）之中。根据虚拟机当前运行状态的不同，如是否启用偏向锁等，对象头会有不同的设置方式。

在上面工作都完成之后，从虚拟机的视角来看，一个新的对象已经产生了。但是从Java程序的视角看来，对象创建才刚刚开始——构造函数，即Class文件中的()方法还没有执行，所有的字段都为默认的零值，对象需要的其他资源和状态信息也还没有按照预定的意图构造好。

一般来说（由字节码流中new指令后面是否跟随invokespecial指令所决定，Java编译器会在遇到new关键字的地方同时生成这两条字节码指令，但如果直接通过其他方式产生的则不一定如此），new指令之后会接着执行()方法，按照程序员的意愿对对象进行初始化，这样一个真正可用的对象才算完全被构造出来。

对象的内部布局

对象在堆内存中的存储布局可以划分为三个部分：对象头（Header）、实例数据（InstanceData）和对齐填充（Padding）

• 对象头
  对象的对象头部分包括两类信息

1. 第一类是用于存储对象自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等，这部分数据的长度在32位和64位的虚拟机（未开启压缩指针）中分别为32个比特和64个比特，官方称它为“MarkWord”。
2. 另外一部分是类型指针，即对象指向它的类型元数据的指针，Java虚拟机通过这个指针来确定该对象是哪个类的实例。并不是所有的虚拟机实现都必须在对象数据上保留类型指针；如果对象是一个Java数组，那在对象头中还必须有一块用于记录数组长度的数据

• 实例数据
  实例数据部分是对象真正存储的有效信息，这部分的存储顺序会受到虚拟机分配策略参数（-XX：FieldsAllocationStyle参数）和字段在Java源码中定义顺序的影响。HotSpot虚拟机默认的分配顺序为longs/doubles、ints、shorts/chars、bytes/booleans、oops（OrdinaryObjectPointers，OOPs），从以上默认的分配策略中可以看到，相同宽度的字段总是被分配到一起存放，在满足这个前提条件的情况下，在父类中定义的变量会出现在子类之前。

• 对齐填充

  第三部分是对齐填充，这并不是必然存在的，也没有特别的含义，它仅仅起着占位符的作用。

  由于HotSpot虚拟机的自动内存管理系统要求对象起始地址必须是8字节的整数倍，换句话说就是任何对象的大小都必须是8字节的整数倍。对象头部分已经被精心设计成正好是8字节的倍数（1倍或者2倍），因此，如果对象实例数据部分没有对齐的话，就需要通过对齐填充来补全。

对象的访问定位

对象访问方式也是由虚拟机实现而定的，主流的访问方式主要有使用句柄和直接指针两种：

• 使用句柄

  如果使用句柄访问的话，Java堆中将可能会划分出一块内存来作为句柄池，reference中存储的就是对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自具体的地址信息，

  • 使用句柄来访问的最大好处就是reference中存储的是稳定句柄地址，在对象被移动（垃圾收集时移动对象是非常普遍的行为）时只会改变句柄中的实例数据指针，而reference本身不需要被修改。

• 直接指针

  如果使用直接指针访问的话，Java堆中对象的内存布局就必须考虑如何放置访问类型数据的相关信息，reference中存储的直接就是对象地址，如果只是访问对象本身的话，就不需要多一次间接访问的开销，

  • 使用直接指针来访问最大的好处就是速度更快，它节省了一次指针定位的时间开销，
  • HotSpot而言，它主要使用第二种方式进行对象访问

虚拟机类加载机制

定义虚拟机的类加载机制

Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型的过程

类加载时机

一个类型从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期将会经历加载（Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（Using）和卸载（Unloading）七个阶段，其中验证、准备、解析三个部分统称为连接（Linking）

加载、验证、准备、初始化和卸载这五个阶段的顺序是确定的。类型的加载过程必须按照这种顺序按部就班地开始，而解析阶段则不一定：它在某些情况下可以在初始化阶段之后再开始，这是为了支持Java语言的运行时绑定特性（也称为动态绑定或晚期绑定）

对于初始化阶段，《Java虚拟机规范》则是严格规定了有且只有六种情况必须立即对类进行“初始化”（而加载、验证、准备自然需要在此之前开始）（称为对一个类型进行主动引用。除此之外，所有引用类型的方式都不会触发初始化，称为被动引用）：

• 遇到new、getstatic、putstatic或invokestatic这四条字节码指令时，如果类型没有进行过初始化，则需要先触发其初始化阶段。能够生成这四条指令的典型Java代码场景有：
  • 使用new关键字实例化对象的时候。
  • 读取或设置一个类型的静态字段（被final修饰、已在编译期把结果放入常量池的静态字段除外）的时候。
  • 调用一个类型的静态方法的时候
• 使用java.lang.reflect包的方法对类型进行反射调用的时候，如果类型没有进行过初始化，则需要先触发其初始化
• 当初始化类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化
• 当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类
• 当使用JDK7新加入的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果为REF_getStatic、REF_putStatic、REF_invokeStatic、REF_newInvokeSpecial四种类型的方法句柄，并且这个方法句柄对应的类没有进行过初始化，则需要先触发其初始化
• 当一个接口中定义了JDK8新加入的默认方法（被default关键字修饰的接口方法）时，如果有这个接口的实现类发生了初始化，那该接口要在其之前被初始化

加载

“加载”（Loading）阶段是整个“类加载”（ClassLoading）过程中的一个阶段

• Java虚拟机需要完成以下三件事情

  • 通过一个类的全限定名来获取定义此类的二进制字节流（加载class文件可以有多种方式）
    • 从ZIP压缩包中读取，这很常见，最终成为日后JAR、EAR、WAR格式的基础
    • 从网络中获取，这种场景最典型的应用就是WebApplet
    • 运行时计算生成，这种场景使用得最多的就是动态代理技术，在java.lang.reflect.Proxy中，就是用了ProxyGenerator.generateProxyClass()来为特定接口生成形式为“*$Proxy”的代理类的二进制字节流
    • 由其他文件生成，典型场景是JSP应用，由JSP文件生成对应的Class文件
    • 从数据库中读取，这种场景相对少见些，例如有些中间件服务器（如SAPNetweaver）可以选择把程序安装到数据库中来完成程序代码在集群间的分发
    • 可以从加密文件中获取，这是典型的防Class文件被反编译的保护措施，通过加载时解密Class文件来保障程序运行逻辑不被窥探
  • 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
  • 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口

• 非数组类型的加载阶段（准确地说，是加载阶段中获取类的二进制字节流的动作）可以通过定义自己的类加载器去控制字节流的获取方式（重写一个类加载器的findClass()或loadClass()方法）

• 对于数组类而言，情况就有所不同，数组类本身不通过类加载器创建，它是由Java虚拟机直接在内存中动态构造出来的

• 数组类的元素类型（ElementType，指的是数组去掉所有维度的类型）最终还是要靠类加载器来完成加载，一个数组类（下面简称为C）创建过程遵循以下规则

  • 如果数组的组件类型（ComponentType，指的是数组去掉一个维度的类型，注意和前面的元素类型区分开来）是引用类型，那就递归加载这个组件类型，数组C将被标识在加载该组件类型的类加载器的类名称空间上
  • 如果数组的组件类型不是引用类型（例如int[]数组的组件类型为int），Java虚拟机将会把数组C标记为与引导类加载器关联
  • 数组类的可访问性与它的组件类型的可访问性一致，如果组件类型不是引用类型，它的数组类的可访问性将默认为public，可被所有的类和接口访问到

• 加载阶段结束后，Java虚拟机外部的二进制字节流就存储在方法区之中了。类型数据妥善安置在方法区之后，会在Java堆内存中实例化一个java.lang.Class类的对象，这个对象将作为程序访问方法区中的类型数据的外部接口

• 加载阶段与连接阶段的部分动作（如一部分字节码文件格式验证动作）是交叉进行的，加载阶段尚未完成，连接阶段可能已经开始

验证

• 验证是连接阶段的第一步，这一阶段的目的是确保Class文件的字节流中包含的信息符合《Java虚拟机规范》的全部约束要求，保证这些信息被当作代码运行后不会危害虚拟机自身的安全

• 决定了Java虚拟机是否能承受恶意代码的攻击，从代码量和耗费的执行性能的角度上讲，验证阶段的工作量在虚拟机的类加载过程中占了相当大的比重

验证过程

验证阶段大致上会完成下面四个阶段的检验动作：文件格式验证、元数据验证、字节码验证和符号引用验证

文件格式验证

验证字节流是否符合Class文件格式的规范，并且能被当前版本的虚拟机处理。
可能包括下面这些验证点,但不局限于：

• 是否以魔数0xCAFEBABE开头
• 主、次版本号是否在当前Java虚拟机接受范围之内
• 常量池的常量中是否有不被支持的常量类型（检查常量tag标志）
• 指向常量的各种索引值中是否有指向不存在的常量或不符合类型的常量
• CONSTANT_Utf8_info型的常量中是否有不符合UTF-8编码的数据
• Class文件中各个部分及文件本身是否有被删除的或附加的其他信息
  …

这阶段的验证是基于二进制字节流进行的，只有通过了这个阶段的验证之后，这段字节流才被允许进入Java虚拟机内存的方法区中进行存储

后面的三个验证阶段全部是基于方法区的存储结构上进行的，不会再直接读取、操作字节流了

元数据验证

对字节码描述的信息进行语义分析，以保证其描述的信息符合《Java语言规范》的要求。可能包括下面这些验证点,但不局限于：

• 这个类是否有父类（除了java.lang.Object之外，所有的类都应当有父类）
• 这个类的父类是否继承了不允许被继承的类（被final修饰的类）
• 如果这个类不是抽象类，是否实现了其父类或接口之中要求实现的所有方法
• 类中的字段、方法是否与父类产生矛盾（例如覆盖了父类的final字段，或者出现不符合规则的方法重载，例如方法参数都一致，但返回值类型却不同等）

字节码验证

通过数据流分析和控制流分析，确定程序语义是合法的、符合逻辑的。对类的方法体（Class文件中的Code属性）进行校验分析，保证被校验类的方法在运行时不会做出危害虚拟机安全的行为。例如：

• 保证任意时刻操作数栈的数据类型与指令代码序列都能配合工作，例如不会出现类似于“在操作栈放置了一个int类型的数据，使用时却按long类型来加载入本地变量表中”这样的情况
• 保证任何跳转指令都不会跳转到方法体以外的字节码指令上
• 保证方法体中的类型转换总是有效的，例如可以把一个子类对象赋值给父类数据类型，这是安全的，但是把父类对象赋值给子类数据类型，甚至把对象赋值给与它毫无继承关系、完全不相干的一个数据类型，则是危险和不合法的

符号引用验证

在虚拟机将符号引用转化为直接引用的时候，这个转化动作将在连接的第三阶段——解析阶段中发生。

通俗来说就是，该类是否缺少或者被禁止访问它依赖的某些外部类、方法、字段等资源。本阶段通常需要校验下列内容，但不局限于：

• 符号引用中通过字符串描述的全限定名是否能找到对应的类
• 在指定类中是否存在符合方法的字段描述符及简单名称所描述的方法和字段
• 符号引用中的类、字段、方法的可访问性（private、protected、public、<package>）是否可被当前类访问

准备

准备阶段是正式为类中定义的变量（即静态变量，被static修饰的变量）分配内存并设置类变量初始值的阶段，从概念上讲，这些变量所使用的内存都应当在方法区中进行分配

方法区本身是一个逻辑上的区域，在JDK7及之前，HotSpot使用永久代来实现方法区时，实现是完全符合这种逻辑概念的；而在JDK8及之后，类变量则会随着Class对象一起存放在Java堆中，这时候“类变量在方法区”就完全是一种对逻辑概念的表述了

进行内存分配的仅包括类变量，而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在Java堆中.

类变量在准备阶段会设置成初始值（零值），赋值是在类构造器<clinit>()方法中进行的（类的初始化过程）

类字段的字段属性表中存在ConstantValue属性，那在准备阶段变量值就会被初始化为ConstantValue属性所指定的初始值，即常量（static final）会在准备阶段直接进行赋值。

解析

• 引用定义
  • 符号引用
    • 符号引用以一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可
    • 内存无关，虚拟机不同时也表现相同
  • 直接引用
    • 可以直接指向目标的指针、相对偏移量或者是一个能间接定位到目标的句柄
    • 直接引用是和虚拟机实现的内存布局直接相关的
      Java虚拟机将常量池内的符号引用替换为直接引用的过程
• 《Java虚拟机规范》之中并未规定解析阶段发生的具体时间，只要求了在执行ane-warray、checkcast、getfield、getstatic、instanceof、invokedynamic、invokeinterface、invoke-special、invokestatic、invokevirtual、ldc、ldc_w、ldc2_w、multianewarray、new、putfield和putstatic这17个用于操作符号引用的字节码指令之前，先对它们所使用的符号引用进行解析
• 对方法或者字段的访问，也会在解析阶段中对它们的可访问性（public、protected、private、<package>）进行检查
• 对同一个符号引用进行多次解析请求是很常见的事情，除invokedynamic指令以外，虚拟机实现可以对第一次解析的结果进行缓存，譬如在运行时直接引用常量池中的记录，并把常量标识为已解析状态，从而避免解析动作重复进行
• invokedynamic指令的目的本来就是用于动态语言支持
• 解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符这7类符号引用进行，分别对应于常量池的CONSTANT_Class_info、CON-STANT_Fieldref_info、CONSTANT_Methodref_info、CONSTANT_InterfaceMethodref_info、CONSTANT_MethodType_info、CONSTANT_MethodHandle_info、CONSTANT_Dyna-mic_info和CONSTANT_InvokeDynamic_info8种常量类型

类或接口的解析

假设当前代码所处的类为D，如果要把一个从未解析过的符号引用N解析为一个类或接口C的直接引用，那虚拟机完成整个解析的过程需要包括以下3个步骤

• 如果C不是一个数组类型，那虚拟机将会把代表N的全限定名传递给D的类加载器去加载这个类C。在加载过程中，由于元数据验证、字节码验证的需要，又可能触发其他相关类的加载动作，例如加载这个类的父类或实现的接口。一旦这个加载过程出现了任何异常，解析过程就将宣告失败。
• 如果C是一个数组类型，并且数组的元素类型为对象，也就是N的描述符会是类似“[Ljava/lang/Integer”的形式，那将会按照第一点的规则加载数组元素类型。如果N的描述符如前面所假设的形式，需要加载的元素类型就是“java.lang.Integer”，接着由虚拟机生成一个代表该数组维度和元素的数组对象。- 如果上面两步没有出现任何异常，那么C在虚拟机中实际上已经成为一个有效的类或接口了，但在解析完成前还要进行符号引用验证，确认D是否具备对C的访问权限。如果发现不具备访问权限，将抛出java.lang.IllegalAccessError异常
  • 即使是public也需要考虑在JDK9之后的模块化的影响。

字段解析

要解析一个未被解析过的字段符号引用，首先将会对字段表内class_index项中索引的CONSTANT_Class_info符号引用进行解析，也就是字段所属的类或接口的符号引用。如果在解析这个类或接口符号引用的过程中出现了任何异常，都会导致字段符号引用解析的失败。如果解析成功完成，那把这个字段所属的类或接口用C表示，《Java虚拟机规范》要求按照如下步骤对C进行后续字段的搜索

• 如果C本身就包含了简单名称和字段描述符都与目标相匹配的字段，则返回这个字段的直接引用，查找结束。
• 否则，如果在C中实现了接口，将会按照继承关系从下往上递归搜索各个接口和它的父接口，如果接口中包含了简单名称和字段描述符都与目标相匹配的字段，则返回这个字段的直接引用，查找结束。
• 否则，如果C不是java.lang.Object的话，将会按照继承关系从下往上递归搜索其父类，如果在父类中包含了简单名称和字段描述符都与目标相匹配的字段，则返回这个字段的直接引用，查找结束。
• 否则，查找失败，抛出java.lang.NoSuchFieldError异常

如果查找过程成功返回了引用，将会对这个字段进行权限验证，如果发现不具备对字段的访问权限，将抛出java.lang.IllegalAccessError异常

但在实际情况中，Javac编译器往往会采取比上述规范更加严格一些的约束，譬如有一个同名字段同时出现在某个类的接口和父类当中，或者同时在自己或父类的多个接口中出现，按照解析规则仍是可以确定唯一的访问字段，但Javac编译器就可能直接拒绝其编译为Class文件

方法解析

方法解析的第一个步骤与字段解析一样，也是需要先解析出方法表的class_index项中索引的方法所属的类或接口的符号引用，如果解析成功，那么我们依然用C表示这个类，接下来虚拟机将会按照如下步骤进行后续的方法搜索

• 由于Class文件格式中类的方法和接口的方法符号引用的常量类型定义是分开的，如果在类的方法表中发现class_index中索引的C是个接口的话，那就直接抛出java.lang.IncompatibleClassChangeError异常
• 如果通过了第一步，在类C中查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束
• 否则，在类C的父类中递归查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束
• 否则，在类C实现的接口列表及它们的父接口之中递归查找是否有简单名称和描述符都与目标相匹配的方法，如果存在匹配的方法，说明类C是一个抽象类，这时候查找结束，抛出java.lang.AbstractMethodError异常
• 否则，宣告方法查找失败，抛出java.lang.NoSuchMethodError

如果查找过程成功返回了直接引用，将会对这个方法进行权限验证，如果发现不具备对此方法的访问权限，将抛出java.lang.IllegalAccessError异常

接口方法解析

接口方法也是需要先解析出接口方法表的class_index项中索引的方法所属的类或接口的符号引用，如果解析成功，依然用C表示这个接口，接下来虚拟机将会按照如下步骤进行后续的接口方法搜索

• 与类的方法解析相反，如果在接口方法表中发现class_index中的索引C是个类而不是接口，那么就直接抛出java.lang.IncompatibleClassChangeError异常
• 否则，在接口C中查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束
• 否则，在接口C的父接口中递归查找，直到java.lang.Object类（接口方法的查找范围也会包括Object类中的方法）为止，看是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束
• 对于规则3，由于Java的接口允许多重继承，如果C的不同父接口中存有多个简单名称和描述符都与目标相匹配的方法，那将会从这多个方法中返回其中一个并结束查找，《Java虚拟机规范》中并没有进一步规则约束应该返回哪一个接口方法
• 否则，宣告方法查找失败，抛出java.lang.NoSuchMethodError异常

初始化

类的初始化阶段是类加载过程的最后一个步骤，之前介绍的几个类加载的动作里，除了在加载阶段用户应用程序可以通过自定义类加载器的方式局部参与外，其余动作都完全由Java虚拟机来主导控制

直到初始化阶段，Java虚拟机才真正开始执行类中编写的Java程序代码，将主导权移交给应用程序

• 初始化阶段就是执行类构造器<clinit>()方法的过程.
  • <clinit>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}块）中的语句合并产生的，
    • 编译器收集的顺序是由语句在源文件中出现的顺序决定的
    • 静态语句块中只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块可以赋值，但是不能访问(提示非法向前访问)
  • <clinit>()方法与类的构造函数（即在虚拟机视角中的实例构造器<init>()方法）不同，它不需要显式地调用父类构造器
    • Java虚拟机会保证在子类的<clinit>()方法执行前，父类的<clinit>()方法已经执行完毕。因此在Java虚拟机中第一个被执行的<clinit>()方法的类型肯定是java.lang.Object
  • 由于父类的<clinit>()方法先执行，也就意味着父类中定义的静态语句块要优先于子类的变量赋值操作
  • <clinit>()方法对于类或接口来说并不是必需的，如果一个类中没有静态语句块，也没有对变量的赋值操作，那么编译器可以不为这个类生成<clinit>()方法
  • 接口中不能使用静态语句块，但仍然有变量初始化的赋值操作，因此接口与类一样都会生成<clinit>()方法。但接口与类不同的是，执行接口的<clinit>()方法不需要先执行父接口的<clinit>()方法，因为只有当父接口中定义的变量被使用时，父接口才会被初始化。此外，接口的实现类在初始化时也一样不会执行接口的<clinit>()方法
  • Java虚拟机必须保证一个类的<clinit>()方法在多线程环境中被正确地加锁同步，如果多个线程同时去初始化一个类，那么只会有其中一个线程去执行这个类的<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行完毕<clinit>()方法

类加载器

通过一个类的全限定名来获取描述该类的二进制字节流,实现这个动作的代码被称为“类加载器”（ClassLoader）

类与类加载器

对于任意一个类，都必须由加载它的类加载器和这个类本身一起共同确立其在Java虚拟机中的唯一性，每一个类加载器，都拥有一个独立的类名称空间

双亲委派模型

• 站在Java虚拟机的角度来看，只存在两种不同的类加载器
  • 启动类加载器（BootstrapClassLoader）
    
    这个类加载器使用C++语言实现，是虚拟机自身的一部分
  • 另外一种就是其他所有的类加载器
    
    这些类加载器都由Java语言实现，独立存在于虚拟机外部，并且全都继承自抽象类java.lang.ClassLoader
• 站在Java开发人员的角度来看
  三层类加载器、双亲委派的类加载架构
  • 启动类加载器（BootstrapClassLoader）
    • 这个类加载器负责加载存放在<JAVA_HOME>\lib目录，或者被-Xbootclasspath参数所指定的路径中存放的，而且是Java虚拟机能够识别的（按照文件名识别，如rt.jar、tools.jar，名字不符合的类库即使放在lib目录中也不会被加载）类库加载到虚拟机的内存中
    • 启动类加载器无法被Java程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给引导类加载器去处理，那直接使用null代替即可
  • 扩展类加载器（ExtensionClassLoader）
    • 在类sun.misc.Launcher$ExtClassLoader中以Java代码的形式实现的。
    • 它负责加载<JAVA_HOME>\lib\ext目录中，或者被java.ext.dirs系统变量所指定的路径中所有的类库
  • 应用程序类加载器（ApplicationClassLoader）
    • 这个类加载器由sun.misc.Launcher$AppClassLoader来实现。
    • 由于应用程序类加载器是ClassLoader类中的getSystemClassLoader()方法的返回值，所以有些场合中也称它为“系统类加载器”。
    • 它负责加载用户类路径（ClassPath）上所有的类库，开发者同样可以直接在代码中使用这个类加载器。
    • 如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器

双亲委派定义

• 各种类加载器之间的层次关系被称为类加载器的"双亲委派模型"
• 双亲委派模型要求除了顶层的启动类加载器外，其余的类加载器都应有自己的父类加载器。
  • 不过这里类加载器之间的父子关系一般不是以继承（Inheritance）的关系来实现的，而是通常使用组合（Composition）关系来复用父加载器的代码

双亲委派工作过程

如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到最顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自己去完成加载

• 好处：Java中的类随着它的类加载器一起具备了一种带有优先级的层次关系
• 实现原理：
  
  先检查请求加载的类型是否已经被加载过，若没有则调用父加载器的loadClass()方法，若父加载器为空则默认使用启动类加载器作为父加载器。假如父类加载器加载失败，抛出ClassNotFoundException异常的话，才调用自己的findClass()方法尝试进行加载

破坏双亲委派模型

主要使用在JNDI、JDBC、JCE、JAXB和JBI等，父类加载器需要调用子类加载器中代码情况，以及热修复场景，如OSGi。

虚拟机字节码执行引擎

概述

• 执行引擎是Java虚拟机核心的组成部分之一
• “虚拟机”是一个相对于“物理机”的概念，这两种机器都有代码执行能力
• 其区别是物理机的执行引擎是直接建立在处理器、缓存、指令集和操作系统层面上的，而虚拟机的执行引擎则是由软件自行实现的，因此可以不受物理条件制约地定制指令集与执行引擎的结构体系，能够执行那些不被硬件直接支持的指令集格式

运行时栈帧结构

• Java虚拟机以方法作为最基本的执行单元
• “栈帧”（StackFrame）则是用于支持虚拟机进行方法调用和方法执行背后的数据结构
  • 它也是虚拟机运行时数据区中的虚拟机栈（VirtualMachineStack）的栈元素
  • 栈帧存储了方法的局部变量表、操作数栈、动态连接和方法返回地址等信息
  • 一个栈帧需要分配多少内存，并不会受到程序运行期变量数据的影响，而仅仅取决于程序源码和具体的虚拟机实现的栈内存布局形式(在编译java代码时就已经确认，写入了方法表的code属性中)
• 每一个方法从调用开始至执行结束的过程，都对应着一个栈帧在虚拟机栈里面从入栈到出栈的过程
• 以Java程序的角度来看，同一时刻、同一条线程里面，在调用堆栈的所有方法都同时处于执行状态
• 对于执行引擎来讲，在活动线程中，只有位于栈顶的方法才是在运行的，只有位于栈顶的栈帧才是生效的，其被称为“当前栈帧”（CurrentStackFrame）
• 与这个栈帧所关联的方法被称为“当前方法”（CurrentMethod）
• 执行引擎所运行的所有字节码指令都只针对当前栈帧进行操作

虚拟机栈和栈帧的总体结构

一个线程对应一个虚拟机栈

虚拟机栈

由多个栈帧构成

栈帧

• 局部变量表
• 操作栈
• 动态连接
• 返回地址
• …

局部变量表

• 是一组变量值的存储空间
• 用于存放方法参数和方法内部定义的局部变量
• 在Java程序被编译为Class文件时，就在方法的Code属性的max_locals数据项中确定了该方法所需分配的局部变量表的最大容量
• 容量以变量槽（VariableSlot）为最小单位
• 《Java虚拟机规范》中并没有明确指出一个变量槽应占用的内存空间大小，只是很有导向性地说到每个变量槽都应该能存放一个boolean、byte、char、short、int、float、reference或returnAddress类型的数据
• Java虚拟机通过索引定位的方式使用局部变量表，索引值的范围是从0开始至局部变量表最大的变量槽数量
• 如果执行的是实例方法（没有被static修饰的方法），那局部变量表中第0位索引的变量槽默认是用于传递方法所属对象实例的引用，在方法中可以通过关键字“this”来访问到这个隐含的参数
• 为了尽可能节省栈帧耗用的内存空间，局部变量表中的变量槽是可以重用的，方法体中定义的变量，其作用域并不一定会覆盖整个方法体，如果当前字节码PC计数器的值已经超出了某个变量的作用域，那这个变量对应的变量槽就可以交给其他变量来重用

  但是这样有可能影响垃圾回收， 当垃圾回收时，还在作用域范围内的数据或者还占着变量槽的话，无法被回收

• 局部变量不像前面介绍的类变量那样存在“准备阶段”。一个局部变量定义了但没有赋初始值，那它是完全不能使用的

操作数栈

• 操作数栈（OperandStack）也常被称为操作栈，它是一个后入先出（LastInFirstOut，LIFO）
• 操作数栈的最大深度也在编译的时候被写入到Code属性的max_stacks数据项之中
• 操作数栈的每一个元素都可以是包括long和double在内的任意Java数据类型
• 32位数据类型所占的栈容量为1，64位数据类型所占的栈容量为2
• 操作数栈的深度都不会超过在max_stacks数据项中设定的最大值
• 当一个方法刚刚开始执行的时候，这个方法的操作数栈是空的
• 在方法的执行过程中，会有各种字节码指令往操作数栈中写入和提取内容，也就是出栈和入栈操作
• Java虚拟机的解释执行引擎被称为“基于栈的执行引擎”，里面的“栈”就是操作数栈

动态连接

• 每个栈帧都包含一个指向运行时常量池[1]中该栈帧所属方法的引用
  • 为了支持方法调用过程中的动态连接（DynamicLinking）
• 字节码中的方法调用指令就以常量池里指向方法的符号引用作为参数。这些符号引用一部分会在类加载阶段或者第一次使用的时候就被转化为直接引用，这种转化被称为静态解析
• 另外一部分将在每一次运行期间都转化为直接引用，这部分就称为动态连接

方法返回地址

• 当一个方法开始执行后，只有两种方式退出这个方法
  • 正常调用完成
    • 执行引擎遇到任意一个方法返回的字节码指令，这时候可能会有返回值传递给上层的方法调用者（调用当前方法的方法称为调用者或者主调方法）
  • 异常调用完成
    • 在方法执行的过程中遇到了异常，并且这个异常没有在方法体内得到妥善处理
• 无论采用何种退出方式，在方法退出之后，都必须返回到最初方法被调用时的位置
• 方法返回时可能需要在栈帧中保存一些信息，用来帮助恢复它的上层主调方法的执行状态
• 一般来说，方法正常退出时，主调方法的PC计数器的值就可以作为返回地址，栈帧中很可能会保存这个计数器值
• 方法异常退出时，返回地址是要通过异常处理器表来确定的，栈帧中就一般不会保存这部分信息
• 方法退出的过程实际上等同于把当前栈帧出栈，退出时可能执行的操作有
  • 恢复上层方法的局部变量表和操作数栈
  • 把返回值（如果有的话）压入调用者栈帧的操作数栈中
  • 调整PC计数器的值以指向方法调用指令后面的一条指令等

方法调用

• 方法调用并不等同于方法中的代码被执行，方法调用阶段唯一的任务就是确定被调用方法的版本（即调用哪一个方法），方法调用有两种方法：解析和分派

解析

• 所有方法调用的目标方法在Class文件里面都是一个常量池中的符号引用，在类加载的解析阶段，会将其中的一部分符号引用转化为直接引用，这种解析能够成立的前提是：方法在程序真正运行之前就有一个可确定的调用版本，并且这个方法的调用版本在运行期是不可改变的.这类方法的调用被称为解析（Resolution）

  调用目标在程序代码写好、编译器进行编译那一刻就已经确定下来

• 在Java语言中符合“编译期可知，运行期不可变”这个要求的方法, 主要有两种，这两种方法各自的特点决定了它们都不可能通过继承或别的方式重写出其他版本，因此它们都适合在类加载阶段进行解析

  • 静态方法
    与类型直接关联
  • 私有方法
    在外部不可被访问

• 在Java虚拟机支持以下5条方法调用字节码指令，分别是

  • invokestatic。用于调用静态方法。
  • invokespecial。用于调用实例构造器()方法、私有方法和父类中的方法。
  • invokevirtual。用于调用所有的虚方法。
  • invokeinterface。用于调用接口方法，会在运行时再确定一个实现该接口的对象。
  • invokedynamic。先在运行时动态解析出调用点限定符所引用的方法，然后再执行该方法。前面4条调用指令，分派逻辑都固化在Java虚拟机内部，而invokedynamic指令的分派逻辑是由用户设定的引导方法来决定的

• 只要能被invokestatic和invokespecial指令调用的方法，都可以在解析阶段中确定唯一的调用版本

  • Java语言里符合这个条件的方法共有静态方法、私有方法、实例构造器、父类方法4种，再加上被final修饰的方法（尽管它使用invokevirtual指令调用）
  • 这5种方法调用会在类加载的时候就可以把符号引用解析为该方法的直接引用。这些方法统称为“非虚方法”
  • 与之相反，其他方法就被称为“虚方法”（VirtualMethod）

• final方法是使用invokevirtual指令来调用的，但是因为它也无法被覆盖

• 解析调用一定是个静态的过程

• 在编译期间就完全确定，在类加载的解析阶段就会把涉及的符号引用全部转变为明确的直接引用，不必延迟到运行期再去完成

分派

• 可能是静态的也可能是动态的
• 按照分派依据的宗量数可分为单分派和多分派
• 这两类分派方式两两组合就构成了静态单分派、静态多分派、动态单分派、动态多分派4种分派组合情况

静态分派

• 所有依赖静态类型来决定方法执行版本的分派动作，都称为静态分派

// Human是变量的静态类型或外观类型，Man是变量的实际类型或运行时类型
Human man = new Man();

• 变量本身的静态类型不会被改变，并且最终的静态类型是在编译期可知的；
• 而实际类型变化的结果在运行期才可确定，编译器在编译程序的时候并不知道一个对象的实际类型是什么
• 静态分派的最典型应用表现就是方法重载
• 虚拟机（或者准确地说是编译器）在重载时是通过参数的静态类型而不是实际类型作为判定依据的

动态分派

• 在运行期根据实际类型确定方法执行版本的分派过程称为动态分派
• 与重写（Override）有着很密切的关联
• invokevirtual指令如何确定调用方法版本、如何实现多态查找
  • 找到操作数栈顶的第一个元素所指向的对象的实际类型，记作C。
  • 如果在类型C中找到与常量中的描述符和简单名称都相符的方法，则进行访问权限校验，如果通过则返回这个方法的直接引用，查找过程结束；不通过则返回java.lang.IllegalAccessError异常。
  • 否则，按照继承关系从下往上依次对C的各个父类进行第二步的搜索和验证过程。
  • 如果始终没有找到合适的方法，则抛出java.lang.AbstractMethodError异常
• 重写的本质
  invokevirtual指令并不是把常量池中方法的符号引用解析到直接引用上就结束了，还会根据方法接收者的实际类型来选择方法版本

public class FieldHasNoPolymorphic{
    static class Father{ 
        public int money = 1;
        public Father(){
            money=2;
            showMeTheMoney();
        }
        public void showMeTheMoney(){
            System.out.println("IamFather,ihave$"+money);
        }
    }
    static class Son extends Father{
        public int money = 3;
        public Son(){
            money=4;
            showMeTheMoney();
        }
        public void showMeTheMoney(){
            System.out.println("IamSon,ihave$"+money);
        }
    }
    public static void main(String[]args){
        Father gay = new Son();
        System.out.println("This gay has$" + gay.money);
    }
}

输出两句都是“IamSon”，这是因为Son类在创建的时候，首先隐式调用了Father的构造函数，而Father构造函数中对showMeTheMoney()的调用是一次虚方法调用，实际执行的版本是Son::showMeTheMoney()方法，所以输出的是“IamSon”，这点经过前面的分析相信读者是没有疑问的了。而这时候虽然父类的money字段已经被初始化成2了，但Son::showMeTheMoney()方法中访问的却是子类的money字段，这时候结果自然还是0，因为它要到子类的构造函数执行时才会被初始化。main()的最后一句通过静态类型访问到了父类中的money，输出了2
上述结果：

I am Son, i have $0

I am Son, i have $4

This gay has $2

单分派与多分派

• 方法的接收者与方法的参数统称为方法的宗量
• 根据分派基于多少种宗量，可以将分派划分为单分派和多分派两种
  • 单分派是根据一个宗量对目标方法进行选择
  • 多分派则是根据多于一个宗量对目标方法进行选择
• Java语言是一门静态多分派、动态单分派的语言

基于栈的字节码解释执行引擎

基于栈的指令集与基于寄存器的指令集

• 基于栈的指令集主要优点是可移植，因为寄存器由硬件直接提供[2]，程序直接依赖这些硬件寄存器则不可避免地要受到硬件的约束
• 栈架构指令集的主要缺点是理论上执行速度相对来说会稍慢一些
• 在解释执行时，栈架构指令集的代码虽然紧凑，但是完成相同功能所需的指令数量一般会比寄存器架构来得更多，因为出栈、入栈操作本身就产生了相当大量的指令

基于栈的指令集

字节码指令流里面的指令大部分都是零地址指令，它们依赖操作数栈进行工作### 引用类型

强引用

强引用对象，垃圾回收永远不会回收掉对象

软引用

在系统将要发生内存溢出异常前，会把软引用对象列入回收范围，进行二次回收，如果回收之后还是没有足够的内存，才会抛出内存溢出异常

弱引用

弱引用对象只会存活到下一次垃圾回收发生之前，只要垃圾回收就会回收掉软引用对象

虚引用

虚引用不会影响对象的生存时间，也无法通过虚引用获取到对象实例，使用虚引用的唯一目的是为了能在这个对象被垃圾回收时收到一个系统通知

finalize()方法

通过可达算法判断不可达的对象也并不一定就会被回收，在回收之前还会经过一次筛选是否有必要执行finalize()方法，如果对象没有覆盖finalize()方法，或者finalize()已经被调用过，则认为是没有必要。

finalize() 每一个对象只会被调用一次。并且finalize()方法不确定性太大，不建议使用。

如果对象被判定有必要执行finalize()方法，那么该对象会被放置在一个名为F-Queue的队列之中，并稍后由一条虚拟机自动创建的，低调度优先级的Finalizer线程去执行他们的finalize()方法，执行指的是会触发这个方法开始，并不保证它的正常运行结束。

这样做的原因是，如果某个对象的finalize()方法执行缓慢，或者更极端地发生了死循环，将很可能导致F-Queue队列中的其他对象永久处于等待，甚至导致整个内存回收子系统的崩溃。

如果对象在finalize()中成功与引用链上的任一对象建立连接，如将自己赋值给某全局变量，则该对象不会被回收，否则对象被回收