类加载与字节码技术

1. 类文件结构
2. 字节码指令
3. 编译期处理
4. 类加载阶段
5. 类加载器
6. 运行期优化

类文件结构

一个简单的 HelloWorld.java

// HelloWorld 示例 
public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("hello world");
    }

}

执行 javac -parameters -d . HellowWorld.java

-parameters会保留方法的参数信息

任何一个Class文件都对应着唯一一个类或接口的定义信息,但是反过来说,类或接口并并不一定都需要定义在文件里(臂如类或接口也可以动态生成，直接送入类加载器中)

编译为 HelloWorld.class 后是这个样子的：

[root@localhost ~]# od -t xC HelloWorld.class 

0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09 

0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07 

0000040 00 1c 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29 

0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e 

0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 12 4c 6f 63 

0000120 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 01 

0000140 00 04 74 68 69 73 01 00 1d 4c 63 6e 2f 69 74 63 

0000160 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c 6f 

0000200 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e 01 00 16 

0000220 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 

0000240 69 6e 67 3b 29 56 01 00 04 61 72 67 73 01 00 13 

0000260 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 

0000300 6e 67 3b 01 00 10 4d 65 74 68 6f 64 50 61 72 61 

0000320 6d 65 74 65 72 73 01 00 0a 53 6f 75 72 63 65 46 

0000340 69 6c 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64 

0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d 0c 00 1e 

0000400 00 1f 01 00 0b 68 65 6c 6c 6f 20 77 6f 72 6c 64 

0000420 07 00 20 0c 00 21 00 22 01 00 1b 63 6e 2f 69 74 

0000440 63 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c 

0000460 6f 57 6f 72 6c 64 01 00 10 6a 61 76 61 2f 6c 61 

0000500 6e 67 2f 4f 62 6a 65 63 74 01 00 10 6a 61 76 61 

0000520 2f 6c 61 6e 67 2f 53 79 73 74 65 6d 01 00 03 6f 

0000540 75 74 01 00 15 4c 6a 61 76 61 2f 69 6f 2f 50 72 

0000560 69 6e 74 53 74 72 65 61 6d 3b 01 00 13 6a 61 76 

0000600 61 2f 69 6f 2f 50 72 69 6e 74 53 74 72 65 61 6d 

0000620 01 00 07 70 72 69 6e 74 6c 6e 01 00 15 28 4c 6a 

0000640 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01 

0000700 00 07 00 08 00 01 00 09 00 00 00 2f 00 01 00 01 

0000720 00 00 00 05 2a b7 00 01 b1 00 00 00 02 00 0a 00 

0000740 00 00 06 00 01 00 00 00 04 00 0b 00 00 00 0c 00 

0000760 01 00 00 00 05 00 0c 00 0d 00 00 00 09 00 0e 00 

0001000 0f 00 02 00 09 00 00 00 37 00 02 00 01 00 00 00 

0001020 09 b2 00 02 12 03 b6 00 04 b1 00 00 00 02 00 0a 

0001040 00 00 00 0a 00 02 00 00 00 06 00 08 00 07 00 0b 

0001060 00 00 00 0c 00 01 00 00 00 09 00 10 00 11 00 00 

0001100 00 12 00 00 00 05 01 00 10 00 00 00 01 00 13 00 

0001120 00 00 02 00 14

class文件是一组以8个字节为基础单位的二进制流，各个数据项目严格按照顺序紧凑地排列在文件之中，中间没有添加任何分隔符，这使得整个Class文件中存储的内容几乎全部都是程序运行时的必要数据，没有空隙存在，当遇到需要占用8个字节以上空间的数据项时，则会按照高位在前的方式，分割为若干个8个字节进行存储

上面编译得到的是十六进制

根据 JVM 规范，类文件结构如下

ClassFile { 

u4 magic; 

u2 minor_version; 

u2 major_version; 

u2 constant_pool_count; 

cp_info constant_pool[constant_pool_count-1]; 

u2 access_flags; 

u2 this_class; 

u2 super_class; 

u2 interfaces_count; 

u2 interfaces[interfaces_count]; 

u2 fields_count; 

field_info fields[fields_count]; 

u2 methods_count; 

method_info methods[methods_count]; 

u2 attributes_count; 

attribute_info attributes[attributes_count]; 

}

Class类文件结构

Class文件格式采用一种类似C语言结构体的伪结构来存储数据，这种伪结构中只有两种数据类型: “无符号数"和"表”.

• 无符号数属于基本数据类型，以u1,u2,u4,u8来分别代表1个字节,2个字节,4个字节和8个字节的无符号数，无符号数可以用来描述数字，索引引用，数量值或者按照UTF-8编码构成字符串值。
• 表是由多个无符号数或者其他数据项构成的复合数据类型
  表用于描述有层次关系的复合结构的数据，整个Class文件本质上也是一张表，这张表由数据项按照严格顺序排列构成

无论是无符号数还是表，当需要描述同一类型但数量不定的多个数据时，经常会使用一个前置的容量计数器加若干连续的数据项的形式，这时候称这一系列集合连续的某一类型的数据为某一类型的集合。

魔数

0~3 字节，表示它是否是【class】类型的文件
0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09

每个class文件头四个字节被称为魔数，它的唯一作用是确定这个文件是否为一个能被虚拟机接收的class文件

版本

4~7 字节，表示类的版本 00 34（52） 表示是 Java 8

0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09

紧接着魔数的四个字节存储的是Class文件的版本号: 第五和第六个字节是次版本号，第7和第8个字节是主版本号

java版本号是从45开始的，JDK1.1之后的JDK大版本发发布主版本号向上加一,注意:虚拟机会拒绝执行超过其版本号的class文件，但是高版本的jdk能向下兼容以前版本的class文件

常量池

常量池可以比喻为Class文件里的资源仓库，它是Class文件结构中与其他项目关联最多的的数据，通常也是占用Class文件空间最大的数据项目之一，另外，他还是class文件中第一个出现的表类型数据项目

常量池中主要存放两大类常量:字面量和符号引用

在Class文件中不会保存各个方法，字段最终在内存中的布局信息，这些字段，方法的符号引用不经过虚拟机在运行期间转换的话是无法得到真正的内存入口地址，也就无法直接被虚拟机使用的。

当虚拟机做类加载时，将会从常量池中获得对应的符号引用，再在类创建时或运行时解析，翻译到具体的内存地址之中。

由于常量池中常量的数量是不固定的，所以在常量池的入口需要放置一项u2类型的数据，代表常量池的容量计数.与java语言习惯不同，这个容量计数从1开始而非0.

第0项常量通常用于表达不需要引用任何一个常量池项目的含义，这样就可以把索引值设置为0.

class文件中只有常量池的索引从1开始，其他集合类型，包括接口索引集合，字段表集合，方法表集合等的容量计数器都与一般习惯相同，从1开始
常量池中每一项常量都是一张表

• 最初常量表共有11种结构各不相同的表结构数据，后来又新增了6个，截止JDK 13，常量表中分别有17种不同类型的常量

这17张表都有一个共同点: 表结构起始的第一位是一个u1类型的标志位,代表当前常量属于哪种常量类型

并且这17种常量类型各自有着完全独立的数据结构.

举一个例子吧: CONSTANT_Class_info型常量的结构

tag是标志位,它用于区分常量类型。

name_index是常量池的索引值,它指向常量池中一个CONSTANT_Utf8_info类型常量，此常量代表了这个类或者接口的全限定名。

根据name_index的值，可以去常量池中找到对应索引下的常量,这里可以知道指向的是一个CONSTANT_Utf8_info类型常量，下面来看看CONSTANT_Utf8_info类型的结构如表所示:

lenght值说明了这个UTF-8编码的字符串长度是多少个字节，他后面紧跟着的长度为length字节的连续数据是一个使用UTF-8缩略编码表示的字符串。

总结:因为java中的类是很多的，无法通过简单的无符号数来描述一个方法用到了什么类，因此在描述方法的这些信息时，需要引用常量表中的符合引用进行表达

访问标识

在常量池结束后的两个字节代表的是访问标志，标注当前类或者接口的访问信息，例如当前Class是类还是接口，是否为public,是否为abstract，类是否为final等

类索引,父类索引与接口所有集合

类索引,父类索引都是一个u2类型的数据，而接口索引集合是一组u2类型的数据的集合，Class文件中由这三项确定该类型的继承关系，类索引用于确定这个类的全限定名，父类索引确定这个类的父类的全限定名。

除了java.lang.Object外，所有java类的父类索引都不为0

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

对于接口索引，入口第一项为u2类型的数据为接口计数器，表示索引表的容量。

字段表集合

字段表用于描述接口或者类中声明的变量，Java语言中的字段包括类型变量以及实例级变量，但是不包括方法内部声明的变量。

字段可以包括的修饰符有字段的作用域(public,protected,private修饰符),是实例变量还是类变量(static修饰符),并发可见性(violate修饰符,是否强制主内存读写),可变性(final修饰符),可否被序列化(transient修饰符),字段数据类型(基本类型，对象，数组)，字段名称。

修饰符可以用标志位来标志，而字段名，字段数据类型这些必须通过常量池中的常量来描述。

字段表的最终格式如下:

name_index就是字段名称，而descriptor_index是字段的描述符，描述字段的数据类型，方法的参数列表(包括数量,顺序以及类型)和返回值。

根据描述规则，基本数据类型以及代表无返回值的void类型都用一个大写字符来表示，而对象类型则用字符L加对象的全限定名来表示

对于数组类型，每一维度用一个[来表示，例如一维整型数组int [],将被记录为[I,二维整型数组int [][]，将被记录为[[I

描述符描述方法时，按照先参数列表后返回值进行描述，参数列表按照参数顺序严格排列在一个()内部。

字段表不会列出从父类或者父接口继承来的字段。

descriptor_index属性之后还有一个属性表集合，用户存储一些额外信息，字段表可以在属性表中附加描述零至多项额外信息。

方法表集合

Class文件存储结构中对方法的描述与对字段的描述采用了几乎一致的方式，方法表的结构如同字段表一样，依次包括访问标志，名称索引，描述符索引，属性表集合。

方法的访问标志相较于字段来说，少了volatile和transient，多了synchronized，native，strictfp和abstract。

方法的定义可以通过访问标志，名称索引，描述符索引来表达清楚，但方法里面的代码去哪里了呢？

• 方法里的代码,经过Javac编译成字节码指令后，存放在方法属性表集合中一个名为"Code"的属性里面

与字段表类似，如果子类没有重写父类方法，方法表集合不会出现父类方法信息，但是会出现由编译器自动添加的方法，例如类构造器方法"< clinit >（）"和 “< init > ()”。

属性表

Class文件的字段表和方法表都可以携带自己的属性表集合,以描述某些场景的专有信息。

对于每一个属性,它的名称都要从常量池中引用一个CONSTANT_Utf8_info类型的常量来表示，而属性表的结构则是完全自定义的，只需要通过一个u4长度属性去说明属性值所占用的位数即可。

Code属性

Java程序方法体内的代码经过Javac编译器处理之后,最终变为字节码指令存储在Code属性内。

Code属性出现在方法表的属性集合之中，但并非所有的方法表都必须存在这个属性，臂如接口和抽象类中的方法就不存在Code顺序。

这里重点挑里面几个属性讲解:

• max_stack代表操作数栈深度的最大值，在方法执行的任意时刻，操作数栈都不会超过这个深度，虚拟机会根据这个值来分配栈帧
• max_locals代表局部变量表所需要的存储空间
• max_locals的单位是变量槽,变量槽是虚拟机为局部变量分配内存所使用的最小内存。
• code_length和code用来存放Java源码编译后生成的字节码指令。code_length代表字节码长度，code是用于存储字节码指令的一系列字节流。

Code属性是Class文件中最重要的一个属性，如果把一个Java程序中的信息分为代码和元数据(包括类,字段,方法定义及其他信息)两部分，那么在整个Class文件里，Code属性用于描述代码，所有的其他数据项目都用户描述元数据。

类文件结构小结

首先回顾一下Class文件格式

Class文件结构不像XML等描述语言，由于它没有任何分割符号，所以无论是顺序还是数量，甚至是存储的字节序，都是被严格限定的，哪个字节表示什么含义，长度是多少，先后顺序如何，全部都不能改变。

Class文件格式为:

• 魔数
• 次版本号
• 主版本号
• 常量池中常量数量，特例从1算起
• 常量池数组存放当前类中所有的常量，常量池中每一项常量都是一个表，类比结构体
• 类访问标志
• 当前类描述信息
• 父类描述信息
• 接口数量
• 接口数组
• 字段数量（实例变量和类变量，不是局部变量）
• 字段数组
• 方法数量
• 方法数组
• 属性数量
• 属性表集合—里面存放不同的属性

字节码指令

Java虚拟机指令由一个字节长度的，代表着某种特定操作含义的数字(成为操作码Opcode),以及跟随其后的零至多个代表此操作数所需的参数(称为操作数,Operand)构成。

由于Java虚拟机采用面向操作数栈而不是面向寄存器的架构，所以大多数指令都不包含操作数，只有一个操作码，指令参数都存放在操作数栈中。

字节码与数据类型

Java虚拟机的指令集中，并且大多数指令都包含其操作所对应的数据类型信息。

对于大部分与数据类型相关的字节码指令，他们的操作码助记符中都有特殊字符来表明专门为哪种数据类型服务：

• i代表对int类型数据的操作
• l代表long
• s代表short
• b代表byte
• c代表char
• f代表float
• d代表double
• a代表reference

也有一些指令的助记符没有明确指明操作类型的字母，例如arraylength指令，它没有代表数据类型的特殊字符，但操作数只能是一个数组类型的对象.

注意:在处理boolean,byte,short和char类型数据或者类型数组时，会转换为使用对应的int类型的字节码指令来处理

加载和存储指令

加载和存储指令用于将数据在栈帧的局部变量表和操作数栈之间来回传输，这类指令包括:

• 将一个局部变量加载到操作栈: iload,iload_< n >, fload…,aload,aload_< n > 中间省略的右f,l,d类型的数据操作指令
• 将一个数值从操作数栈存储到局部变量表中: istore,istore_< n > … 同上
• 将一个常量加载到操作数栈中: bipush,sipush,ldc,ldc_w,ldc2_w,aconst_null,iconst_m1,iconst_< i >,lconst_< l >,fconst_< f >,dconst_ < d >
• 扩充局部变量表的访问索引的指令: wide

存储数据的操作数栈和局部变量表主要是由加载和存储指令进行操作，除此之外，还有少量指令，如访问对象的字段或数组元素的指令也会向操作数栈传输数据。

以< >结尾的指令助记符，实际上代表了一组指令，例如iload< n > ，它代表了iload_0,iload_1,iload_2，iload_3这几条指令。

这几组指令都是某个带一个操作数的通用指令。他们省略了显示的操作数，不需要进行取操作数的动作，因为操作数隐含在指令中。

例如: iload_0与操作数为0时的iload指令语义一致。

补充

除了加载和存储指令还有运算指令，类型转换指令，对象创建和访问指令,操作数栈管理指令，控制转移指令(if,switch)，方法调用和返回指令,异常处理指令和同步指令。

这里就不展开对每个指令进行介绍了，感兴趣的可以自行去查找相关指令介绍。

注意:在java程序中，显示抛出异常的操作(throw语句)都由athrow指令来实现。在java虚拟机中,处理异常(catch语句)不是通过字节码指令实现的，而是采用异常表实现的。

同步指令是检查方法的访问标志ACC_SYNCHROIZED是否被设置，即是否为同步方法，

如果设置了,就先要求执行线程先成功持有锁，也叫管程(Monitor)，下面统称锁，然后才能执行方法。

最后当方法执行完毕，无论方法是正常还是异常结束，都会释放锁

java虚拟机通过monitorenter和monitorexit两条指令支持synchroized的语义。

为了保证方法异常完成时monitoenter和monitorexit指令依然可以正确配对执行，编译器会自动产生一个异常处理程序，这个异常处理程序声明可以处理所有的异常，它的目的就是用来执行monitorexit指令

实例分析

public com.HelloWorld(); 构造方法的字节码指令

2a b7 00 01 b1

1. 2a => aload_0 加载 slot 0 的局部变量，即 this，做为下面的 invokespecial 构造方法调用的参数
2. b7 => invokespecial 预备调用构造方法，哪个方法呢？
3. 00 01 引用常量池中 #1 项，即【 Method java/lang/Object."< init >" : ( )V 】
4. b1 表示返回

另一个是 public static void main(java.lang.String[]); 主方法的字节码指令

b2 00 02 12 03 b6 00 04 b1

1. b2 => getstatic 用来加载静态变量，哪个静态变量呢？
2. 00 02 引用常量池中 #2 项，即【Field java/lang/System.out:Ljava/io/PrintStream;】
3. 12 => ldc 加载参数，哪个参数呢？
4. 03 引用常量池中 #3 项，即 【String hello world】
5. b6 => invokevirtual 预备调用成员方法，哪个方法呢？
6. 00 04 引用常量池中 #4 项，即【Method java/io/PrintStream.println:(Ljava/lang/String;)V】
7. b1 表示返回

参考官方文档

https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html#jvms-6.5

javap 工具

自己分析类文件结构太麻烦了，Oracle 提供了 javap 工具来反编译 class 文件

操作数栈

1.和局部变量区一样，操作数栈也是被组织成一个以字长为单位的数组。但是和前者不同的是，它不是通过索引来访问，而是通过标准的栈操作—压栈和出栈—来访问的。比如，如果某个指令把一个值压入到操作数栈中，稍后另一个指令就可以弹出这个值来使用。

2.虚拟机在操作数栈中存储数据的方式和在局部变量区中是一样的：如int、long、float、double、reference和returnType的存储。对于byte、short以及char类型的值在压入到操作数栈之前，也会被转换为int。

3.不同于程序计数器，Java虚拟机没有寄存器，程序计数器也无法被程序指令直接访问。Java虚拟机的指令是从操作数栈中而不是从寄存器中取得操作数的，因此它的运行方式是基于栈的而不是基于寄存器的。虽然指令也可以从其他地方取得操作数，比如从字节码流中跟随在操作码（代表指令的字节）之后的字节中或从常量池中，但是主要还是从操作数栈中获得操作数。

4.虚拟机把操作数栈作为它的工作区——大多数指令都要从这里弹出数据，执行运算，然后把结果压回操作数栈。比如，iadd指令就要从操作数栈中弹出两个整数，执行加法运算，其结果又压回到操作数栈中，看看下面的示例，它演示了虚拟机是如何把两个int类型的局部变量相加，再把结果保存到第三个局部变量的：

begin

iload_0 // push the int in local variable 0 onto the stack

iload_1 // push the int in local variable 1 onto the stack

iadd // pop two ints, add them, push result

istore_2 // pop int, store into local variable 2

end

在这个字节码序列里，前两个指令iload_0和iload_1将存储在局部变量中索引为0和1的整数压入操作数栈中，其后iadd指令从操作数栈中弹出那两个整数相加，再将结果压入操作数栈。第四条指令istore_2则从操作数栈中弹出结果，并把它存储到局部变量区索引为2的位置。图5-10详细表述了这个过程中局部变量和操作数栈的状态变化，图中没有使用的局部变量区和操作数栈区域以空白表示。

大白话,先看图

其实上面的5点概念,可以描述为上图这样

首先从冰箱(局部变量表)里取出肉和苦瓜放在两个盘子(两个盘子构成的操作数栈)里,然后经过放在锅里炒后,又放回栈里(其中一个盘子),最后可以把抄好的苦瓜炒肉放到冰箱第三格存起来改天吃

java虚拟机栈是方法调用和执行的空间，每个方法会封装成一个栈帧压入占中。其中里面的操作数栈用于进行运算，当前线程只有当前执行的方法才会在操作数栈中调用指令（可见java虚拟机栈的指令主要取于操作数栈）。

图解

常量池载入运行时常量池

当程序开始运行的时候，会将编译后class文件常量池里面的常量都载入运行时常量池,除了保存Class文件描述中的符号引用外，还会把符号引用翻译出来的直接引用也存储在运行时常量池中。

运行时常量池也是方法区的一部分

方法字节码载入方法区

如果数值较小的情况下就直接和字节码指令放在一块，否则会放入运行时常量池中保存

main 线程开始运行，分配栈帧内存

（stack=2，locals=4）

locals是局部变量的数量，这里具体指变量槽的数量

stack指的是操作数栈最大深度,这个值也决定了当前栈帧的大小

执行引擎开始执行字节码

bipush 10

将一个 byte 压入操作数栈（其长度会补齐 4 个字节），类似的指令还有

sipush 将一个 short 压入操作数栈（其长度会补齐 4 个字节）

ldc 将一个 int 压入操作数栈

ldc2_w 将一个 long 压入操作数栈（分两次压入，因为 long 是 8 个字节）

这里小的数字都是和字节码指令存在一起，超过 short 范围的数字存入了常量池

istore_1

将操作数栈顶数据弹出，存入局部变量表的 slot 1

ldc #3

• 从常量池加载 #3 数据到操作数栈

注意 Short.MAX_VALUE 是 32767，所以 32768 = Short.MAX_VALUE + 1 实际是在编译期间计算好的

istore_2

iload_1

iload_2

iadd

istore_3

getstatic #4

iload_3

invokevirtual #5

• 找到常量池 #5 项
• 定位到方法区 java/io/PrintStream.println:(I)V 方法
• 生成新的栈帧（分配 locals、stack等）
• 传递参数，执行新栈帧中的字节码

• 执行完毕，弹出栈帧
• 清除 main 操作数栈内容

return

• 完成 main 方法调用，弹出 main 栈帧
• 程序结束

练习 - 分析 i++

目的：从字节码角度分析 a++ 相关题目

源码：

/*** 从字节码角度分析 a++ 相关题目 */
public class Demo3_2 {
    public static void main(String[] args) {
        int a = 10;
        int b = a++ + ++a + a--;
        System.out.println(a);
        System.out.println(b);
    }
}

字节码：

分析：

• 注意 iinc 指令是直接在局部变量 slot 上进行运算
• a++ 和 ++a 的区别是先执行 iload 还是 先执行 iinc

条件判断指令

几点说明：

• byte，short，char 都会按 int 比较，因为操作数栈都是 4 字节
• goto 用来进行跳转到指定行号的字节码

源码：

public class Demo3_3 {
    public static void main(String[] args) {
        int a = 0;
        if (a == 0) {
            a = 10;
        } else {
            a = 20;
        }
    }
}

字节码：

思考

细心的同学应当注意到，以上比较指令中没有 long，float，double 的比较，那么它们要比较怎
么办？

参考 https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.lcmp

循环控制指令

其实循环控制还是前面介绍的那些指令，例如 while 循环：

public class Demo3_4 {
    public static void main(String[] args) {
        int a = 0;
        while (a < 10) {
            a++;
        }
    }
}

字节码是：

再比如 do while 循环：

public class Demo3_5 {
    public static void main(String[] args) {
        int a = 0;
        do {
            a++;
        } while (a < 10);
    }
}

最后再看看 for 循环：

public class Demo3_6 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
        }
    }
}

字节码是：

注意

比较 while 和 for 的字节码，你发现它们是一模一样的，殊途也能同归😊

练习 - 判断结果

请从字节码角度分析，下列代码运行的结果：

public class Demo3_6_1 {
    public static void main(String[] args) {
        int i = 0;
        int x = 0;
        while (i < 10) {
            x = x++;
            i++;
        }
        System.out.println(x); // 结果是 0 
         } 
}

之所以是0，是因为x++底层对应的字节码指令为先执行iload,再执行iinc,这样的话，就是先把0放入操作数栈中，然后x在变量槽完成自增操作变为1后，等号赋值指令，又把操作数栈中的0取出完成赋值，此时x的值又改为了0，因此x最终的值还是为0

构造方法

< cinit >()V

public class Demo3_8_1 {
    static int i = 10;

    static {
        i = 20;
    }

    static {
        i = 30;
    }
}

编译器会按从上至下的顺序，收集所有 static 静态代码块和静态成员赋值的代码，合并为一个特殊的方法 < cinit >()V ：

< cinit >()V 方法会在类加载的初始化阶段被调用

所以这里最终i的值为30

< init >()V

public class Demo3_8_2 {
    private String a = "s1";

    {
        b = 20;
    }

    private int b = 10;

    {
        a = "s2";
    }

    public Demo3_8_2(String a, int b) {
        this.a = a;
        this.b = b;
    }

    public static void main(String[] args) {
        Demo3_8_2 d = new Demo3_8_2("s3", 30);
        System.out.println(d.a);
        System.out.println(d.b);
    }
}

编译器会按从上至下的顺序，收集所有 {} 代码块和成员变量赋值的代码，形成新的构造方法，但原始构造方法内的代码总是在最后

方法调用

看一下几种不同的方法调用对应的字节码指令

字节码

• new 是创建【对象】，给对象分配堆内存，执行成功会将【对象引用】压入操作数栈
• dup 是赋值操作数栈栈顶的内容，本例即为【对象引用】，为什么需要两份引用呢，一个是要配 合 invokespecial
  调用该对象的构造方法 “< init >”😦)V （会消耗掉栈顶一个引用），另一个要 配合 astore_1 赋值给局部变量
• 最终方法（final），私有方法（private），构造方法都是由 invokespecial 指令来调用，属于静态绑定
• 普通成员方法是由 invokevirtual 调用，属于动态绑定，即支持多态
• 成员方法与静态方法调用的另一个区别是，执行方法前是否需要【对象引用】
• 比较有意思的是 d.test4(); 是通过【对象引用】调用一个静态方法，可以看到在调用 invokestatic 之前执行了
  pop 指令，把【对象引用】从操作数栈弹掉了😂
• 还有一个执行 invokespecial 的情况是通过 super 调用父类方法

多态的原理

/*** 演示多态原理，注意加上下面的 JVM 参数，
禁用指针压缩 * -XX:-UseCompressedOops -XX:-UseCompressedClassPointers */
public class Demo3_10 {
    public static void test(Animal animal) {
        animal.eat();
        System.out.println(animal.toString());
    }

    public static void main(String[] args) throws IOException {
        test(new Cat());
        test(new Dog());
        System.in.read();
    }
}

abstract class Animal {
    public abstract void eat();

    @Override
    public String toString() {
        return "我是" + this.getClass().getSimpleName();
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("啃骨头");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("吃鱼");
    }
}

1）运行代码

停在 System.in.read() 方法上，这时运行 jps 获取进程 id

2）运行 HSDB 工具

进入 JDK 安装目录，执行

java -cp ./lib/sa-jdi.jar sun.jvm.hotspot.HSDB

进入图形界面 attach 进程 id

3）查找某个对象

打开 Tools -> Find Object By Query

输入 select d from cn.itcast.jvm.t3.bytecode.Dog d 点击 Execute 执行

4）查看对象内存结构

点击超链接可以看到对象的内存结构，此对象没有任何属性，因此只有对象头的 16 字节，前 8 字节是MarkWord，后 8 字节就是对象的 Class 指针(类型元数据指针),通过这个指针确定这个对象是哪个类的实例。

但目前看不到它的实际地址

5）查看对象 Class 的内存地址

可以通过 Windows -> Console 进入命令行模式，执行

mem 0x00000001299b4978 2

mem 有两个参数，参数 1 是对象地址，参数 2 是查看 2 行（即 16 字节）结果中第二行 0x000000001b7d4028 即为 Class 的内存地址

6）查看类的 vtable （虚方法表，参考c++中的虚方法表）

• 方法1：Alt+R 进入 Inspector 工具，输入刚才的 Class 内存地址，看到如下界面

• 方法2：或者 Tools -> Class Browser 输入 Dog 查找，可以得到相同的结果

无论通过哪种方法，都可以找到 Dog Class 的 vtable 长度为 6，意思就是 Dog 类有 6 个虚方法（多态相关的，final，static 不会列入）

那么这 6 个方法都是谁呢？从 Class 的起始地址开始算，偏移 0x1b8 就是 vtable 的起始地址，进行计算得到：

0x000000001b7d4028 1b8 
+ --------------------- 
0x000000001b7d41e0

通过 Windows -> Console 进入命令行模式，执行

就得到了 6 个虚方法的入口地址

7）验证方法地址

通过 Tools -> Class Browser 查看每个类的方法定义，比较可知

对号入座，发现

• eat() 方法是 Dog 类自己的
• toString() 方法是继承 String 类的
• finalize() ，equals()，hashCode()，clone() 都是继承 Object 类的

8）小结

当执行 invokevirtual 指令时，

1. 先通过栈帧中的对象引用找到对象
2. 分析对象头，找到对象的实际 Class
3. Class 结构中有 vtable，它在类加载的链接阶段就已经根据方法的重写规则生成好了
4. 查表得到方法的具体地址
5. 执行方法的字节码

虚拟机也会对多态进行优化，例: 如果只有一个子实现类，会采用单态优化法;多次调用方法，进行缓存等…

异常处理

try-catch

注意: 为了抓住重点，下面的字节码省略了不重要的部分

• 可以看到多出来一个 Exception table 的结构，[from, to) 是前闭后开的检测范围，一旦这个范围
  内的字节码执行出现异常，则通过 type 匹配异常类型，如果一致，进入 target 所指示行号
• 8 行的字节码指令 astore_2 是将异常对象引用存入局部变量表的 slot 2 位置

多个 single-catch 块的情况

• 因为异常出现时，只能进入 Exception table 中一个分支，所以局部变量表 slot 2 位置被共用

multi-catch 的情况

最后可以槽位复用，是通过逃逸分析计算得出的，因为test变量的生命周期只在try语句内，不会牵扯到catch块，所以当执行到catch语句时，test变量已经死亡了，它的槽位可以被其他变量复用

finally

可以看到 finally 中的代码被复制了 3 份，分别放入 try 流程，catch 流程以及 catch 剩余的异常类型流程

finally 面试题

finally 出现了 return

先问问自己，下面的题目输出什么？

• 由于 finally 中的 ireturn 被插入了所有可能的流程，因此返回结果肯定以 finally 的为准
• 至于字节码中第 2 行，似乎没啥用，且留个伏笔，看下个例子
• 跟上例中的 finally 相比，发现没有 athrow 了，这告诉我们：如果在 finally 中出现了 return，会吞掉异常😱😱😱，可以试一下下面的代码

finally 对返回值影响

因为最终返回的应该是计算后栈顶的值，所以这边先用slot1固定了返回值，要返回前，将slot1里面的值放入栈顶，然后返回

finally块中的修改对返回值没有影响

finally块中不能写返回值，否则会造成异常被吞掉

synchronized

方法级别的 synchronized 不会在字节码指令中有所体现

为了保证方法异常完成时monitorenter和monitorexit指令依然可以正常配对执行，编译器会自动产生一个异常处理程序，这个异常处理程序声明可以处以所有的异常，它的目的就是用来执行monitorexit指令