← 返回学习路线

SYSTEM

字节码与执行引擎

Java基础字节码system
src/content/notes/system/字节码.md

字节码

跨平台性

Java 语言:跨平台的语言(write once ,run anywhere)

  • 当 Java 源代码成功编译成字节码后,在不同的平台上面运行无须再次编译
  • 让一个 Java 程序正确地运行在 JVM 中,Java 源码就必须要被编译为符合 JVM 规范的字节码

编译过程中的编译器:

  • 前端编译器: Sun 的全量式编译器 javac、 Eclipse 的增量式编译器 ECJ,把源代码编译为字节码文件 .class

    • IntelliJ IDEA 使用 javac 编译器
    • Eclipse 中,当开发人员编写完代码后保存时,ECJ 编译器就会把未编译部分的源码逐行进行编译,而非每次都全量编译,因此 ECJ 的编译效率会比 javac 更加迅速和高效
    • 前端编译器并不会直接涉及编译优化等方面的技术,具体优化细节移交给 HotSpot 的 JIT 编译器负责
  • 后端运行期编译器:HotSpot VM 的 C1、C2 编译器,也就是 JIT 编译器,Graal 编译器

    • JIT 编译器:执行引擎部分详解
    • Graal 编译器:JDK10 HotSpot 加入的一个全新的即时编译器,编译效果短短几年时间就追平了 C2
  • 静态提前编译器:AOT (Ahead Of Time Compiler)编译器,直接把源代码编译成本地机器代码

    • JDK 9 引入,是与即时编译相对立的一个概念,即时编译指的是在程序的运行过程中将字节码转换为机器码,AOT 是程序运行之前便将字节码转换为机器码

    • 优点:JVM 加载已经预编译成二进制库,可以直接执行,不必等待即时编译器的预热,减少 Java 应用第一次运行慢的现象

    • 缺点:

      • 破坏了 Java 一次编译,到处运行,必须为每个不同硬件编译对应的发行包
      • 降低了 Java 链接过程的动态性,加载的代码在编译期就必须全部已知

语言发展

机器码:各种用二进制编码方式表示的指令,与 CPU 紧密相关,所以不同种类的 CPU 对应的机器指令不同

指令:指令就是把机器码中特定的 0 和 1 序列,简化成对应的指令,例如 mov,inc 等,可读性稍好,但是不同的硬件平台的同一种指令(比如 mov),对应的机器码也可能不同

指令集:不同的硬件平台支持的指令是有区别的,每个平台所支持的指令,称之为对应平台的指令集

  • x86 指令集,对应的是 x86 架构的平台
  • ARM 指令集,对应的是 ARM 架构的平台

汇编语言:用助记符代替机器指令的操作码,用地址符号或标号代替指令或操作数的地址

  • 在不同的硬件平台,汇编语言对应着不同的机器语言指令集,通过汇编过程转换成机器指令
  • 计算机只认识指令码,汇编语言编写的程序也必须翻译成机器指令码,计算机才能识别和执行

高级语言:为了使计算机用户编程序更容易些,后来就出现了各种高级计算机语言

字节码:是一种中间状态(中间码)的二进制代码,比机器码更抽象,需要直译器转译后才能成为机器码

  • 字节码为了实现特定软件运行和软件环境,与硬件环境无关
  • 通过编译器和虚拟机器实现,编译器将源码编译成字节码,虚拟机器将字节码转译为可以直接执行的指令

类结构

文件结构

字节码是一种二进制的类文件,是编译之后供虚拟机解释执行的二进制字节码文件,一个 class 文件对应一个 public 类型的类或接口

字节码内容是 JVM 的字节码指令,不是机器码,C、C++ 经由编译器直接生成机器码,所以执行效率比 Java 高

JVM 官方文档:https://docs.oracle.com/javase/specs/jvms/se8/html/index.html

根据 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];
}
类型 名称 说明 长度 数量
u4 magic 魔数,识别类文件格式 4个字节 1
u2 minor_version 副版本号(小版本) 2个字节 1
u2 major_version 主版本号(大版本) 2个字节 1
u2 constant_pool_count 常量池计数器 2个字节 1
cp_info constant_pool 常量池表 n个字节 constant_pool_count-1
u2 access_flags 访问标识 2个字节 1
u2 this_class 类索引 2个字节 1
u2 super_class 父类索引 2个字节 1
u2 interfaces_count 接口计数 2个字节 1
u2 interfaces 接口索引集合 2个字节 interfaces_count
u2 fields_count 字段计数器 2个字节 1
field_info fields 字段表 n个字节 fields_count
u2 methods_count 方法计数器 2个字节 1
method_info methods 方法表 n个字节 methods_count
u2 attributes_count 属性计数器 2个字节 1
attribute_info attributes 属性表 n个字节 attributes_count

Class 文件格式采用一种类似于 C 语言结构体的方式进行数据存储,这种结构中只有两种数据类型:无符号数和表

  • 无符号数属于基本的数据类型,以 u1、u2、u4、u8 来分别代表1个字节、2个字节、4个字节和8个字节的无符号数,无符号数可以用来描述数字、索引引用、数量值或者按照 UTF-8 编码构成字符串
  • 表是由多个无符号数或者其他表作为数据项构成的复合数据类型,表都以 _info 结尾,用于描述有层次关系的数据,整个 Class 文件本质上就是一张表,由于表没有固定长度,所以通常会在其前面加上个数说明

获取方式:

  • HelloWorld.java 执行 javac -parameters -d . HellowWorld.java指令
  • 写入文件指令 javap -v xxx.class >xxx.txt
  • IDEA 插件 jclasslib

魔数版本

魔数:每个 Class 文件开头的 4 个字节的无符号整数称为魔数(Magic Number),是 Class 文件的标识符,代表这是一个能被虚拟机接受的有效合法的 Class 文件,

  • 魔数值固定为 0xCAFEBABE,不符合则会抛出错误

  • 使用魔数而不是扩展名来进行识别主要是基于安全方面的考虑,因为文件扩展名可以随意地改动

版本:4 个 字节,5 6两个字节代表的是编译的副版本号 minor_version,而 7 8 两个字节是编译的主版本号 major_version

  • 不同版本的 Java 编译器编译的 Class 文件对应的版本是不一样的,高版本的 Java 虚拟机可以执行由低版本编译器生成的 Class 文件,反之 JVM 会抛出异常 java.lang.UnsupportedClassVersionError
主版本(十进制) 副版本(十进制) 编译器版本
45 3 1.1
46 0 1.2
47 0 1.3
48 0 1.4
49 0 1.5
50 0 1.6
51 0 1.7
52 0 1.8
53 0 1.9
54 0 1.10
55 0 1.11

图片来源:https://www.bilibili.com/video/BV1PJ411n7xZ


常量池

常量池中常量的数量是不固定的,所以在常量池的入口需要放置一项 u2 类型的无符号数,代表常量池计数器(constant_pool_count),这个容量计数是从 1 而不是 0 开始,是为了满足后面某些指向常量池的索引值的数据在特定情况下需要表达不引用任何一个常量池项目,这种情况可用索引值 0 来表示

constant_pool 是一种表结构,以1 ~ constant_pool_count - 1为索引,表明有多少个常量池表项。表项中存放编译时期生成的各种字面量和符号引用,这部分内容将在类加载后进入方法区的运行时常量池

  • 字面量(Literal) :基本数据类型、字符串类型常量、声明为 final 的常量值等

  • 符号引用(Symbolic References):类和接口的全限定名、字段的名称和描述符、方法的名称和描述符

    • 全限定名:com/test/Demo 这个就是类的全限定名,仅仅是把包名的 . 替换成 /,为了使连续的多个全限定名之间不产生混淆,在使用时最后一般会加入一个 ; 表示全限定名结束

    • 简单名称:指没有类型和参数修饰的方法或者字段名称,比如字段 x 的简单名称就是 x

    • 描述符:用来描述字段的数据类型、方法的参数列表(包括数量、类型以及顺序)和返回值

      标志符 含义
      B 基本数据类型 byte
      C 基本数据类型 char
      D 基本数据类型 double
      F 基本数据类型 float
      I 基本数据类型 int
      J 基本数据类型 long
      S 基本数据类型 short
      Z 基本数据类型 boolean
      V 代表 void 类型
      L 对象类型,比如:Ljava/lang/Object;,不同方法间用;隔开
      [ 数组类型,代表一维数组。比如:double[][][] is [[[D

常量类型和结构:

类型 标志(或标识) 描述
CONSTANT_utf8_info 1 UTF-8编码的字符串
CONSTANT_Integer_info 3 整型字面量
CONSTANT_Float_info 4 浮点型字面量
CONSTANT_Long_info 5 长整型字面量
CONSTANT_Double_info 6 双精度浮点型字面量
CONSTANT_Class_info 7 类或接口的符号引用
CONSTANT_String_info 8 字符串类型字面量
CONSTANT_Fieldref_info 9 字段的符号引用
CONSTANT_Methodref_info 10 类中方法的符号引用
CONSTANT_InterfaceMethodref_info 11 接口中方法的符号引用
CONSTANT_NameAndType_info 12 字段或方法的符号引用
CONSTANT_MethodHandle_info 15 表示方法句柄
CONSTANT_MethodType_info 16 标志方法类型
CONSTANT_InvokeDynamic_info 18 表示一个动态方法调用点

18 种常量没有出现 byte、short、char,boolean 的原因:编译之后都可以理解为 Integer


访问标识

访问标识(access_flag),又叫访问标志、访问标记,该标识用两个字节表示,用于识别一些类或者接口层次的访问信息,包括这个 Class 是类还是接口,是否定义为 public类型,是否定义为 abstract类型等

  • 类的访问权限通常为 ACC_ 开头的常量
  • 每一种类型的表示都是通过设置访问标记的 32 位中的特定位来实现的,比如若是 public final 的类,则该标记为 ACC_PUBLIC | ACC_FINAL
  • 使用 ACC_SUPER 可以让类更准确地定位到父类的方法,确定类或接口里面的 invokespecial 指令使用的是哪一种执行语义,现代编译器都会设置并且使用这个标记
标志名称 标志值 含义
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 标志这是一个枚举

索引集合

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

  • 类索引用于确定这个类的全限定名

  • 父类索引用于确定这个类的父类的全限定名,Java 语言不允许多重继承,所以父类索引只有一个,除了Object 之外,所有的 Java 类都有父类,因此除了 java.lang.Object 外,所有 Java 类的父类索引都不为0

  • 接口索引集合就用来描述这个类实现了哪些接口

    • interfaces_count 项的值表示当前类或接口的直接超接口数量
    • interfaces[] 接口索引集合,被实现的接口将按 implements 语句后的接口顺序从左到右排列在接口索引集合中
长度 含义
u2 this_class
u2 super_class
u2 interfaces_count
u2 interfaces[interfaces_count]

字段表

字段 fields 用于描述接口或类中声明的变量,包括类变量以及实例变量,但不包括方法内部、代码块内部声明的局部变量以及从父类或父接口继承。字段叫什么名字、被定义为什么数据类型,都是无法固定的,只能引用常量池中的常量来描述

fields_count(字段计数器),表示当前 class 文件 fields 表的成员个数,用两个字节来表示

fields[](字段表):

  • 表中的每个成员都是一个 fields_info 结构的数据项,用于表示当前类或接口中某个字段的完整描述

  • 字段访问标识:

    标志名称 标志值 含义
    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_TRANSTENT 0x0080 字段是否为transient
    ACC_SYNCHETIC 0x1000 字段是否为由编译器自动产生
    ACC_ENUM 0x4000 字段是否为enum
  • 字段名索引:根据该值查询常量池中的指定索引项即可

  • 描述符索引:用来描述字段的数据类型、方法的参数列表和返回值

    字符 类型 含义
    B byte 有符号字节型树
    C char Unicode字符,UTF-16编码
    D double 双精度浮点数
    F float 单精度浮点数
    I int 整型数
    J long 长整数
    S short 有符号短整数
    Z boolean 布尔值true/false
    V void 代表void类型
    L Classname reference 一个名为Classname的实例
    [ reference 一个一维数组
  • 属性表集合:属性个数存放在 attribute_count 中,属性具体内容存放在 attribute 数组中,一个字段还可能拥有一些属性,用于存储更多的额外信息,比如初始化值、一些注释信息等

    ConstantValue_attribute{
        u2 attribute_name_index;
        u4 attribute_length;
        u2 constantvalue_index;
    }

    对于常量属性而言,attribute_length 值恒为2


方法表

方法表是 methods 指向常量池索引集合,其中每一个 method_info 项都对应着一个类或者接口中的方法信息,完整描述了每个方法的签名

  • 如果这个方法不是抽象的或者不是 native 的,字节码中就会体现出来
  • methods 表只描述当前类或接口中声明的方法,不包括从父类或父接口继承的方法
  • methods 表可能会出现由编译器自动添加的方法,比如初始化方法 和实例化方法

**重载(Overload)**一个方法,除了要与原方法具有相同的简单名称之外,还要求必须拥有一个与原方法不同的特征签名,特征签名就是一个方法中各个参数在常量池中的字段符号引用的集合,因为返回值不会包含在特征签名之中,因此 Java 语言里无法仅仅依靠返回值的不同来对一个已有方法进行重载。但在 Class 文件格式中,特征签名的范围更大一些,只要描述符不是完全一致的两个方法就可以共存

methods_count(方法计数器):表示 class 文件 methods 表的成员个数,使用两个字节来表示

methods[](方法表):每个表项都是一个 method_info 结构,表示当前类或接口中某个方法的完整描述

  • 方法表结构如下:

    类型 名称 含义 数量
    u2 access_flags 访问标志 1
    u2 name_index 字段名索引 1
    u2 descriptor_index 描述符索引 1
    u2 attrubutes_count 属性计数器 1
    attribute_info attributes 属性集合 attributes_count
  • 方法表访问标志:

    标志名称 标志值 含义
    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_TRANSTENT 0x0080 字段是否为 transient
    ACC_SYNCHETIC 0x1000 字段是否为由编译器自动产生
    ACC_ENUM 0x4000 字段是否为 enum

属性表

属性表集合,指的是 Class 文件所携带的辅助信息,比如该 Class 文件的源文件的名称,以及任何带有 RetentionPolicy.CLASS 或者 RetentionPolicy.RUNTIME 的注解,这类信息通常被用于 Java 虚拟机的验证和运行,以及 Java 程序的调试。字段表、方法表都可以有自己的属性表,用于描述某些场景专有的信息

attributes_ count(属性计数器):表示当前文件属性表的成员个数

attributes[](属性表):属性表的每个项的值必须是 attribute_info 结构

  • 属性的通用格式:

    ConstantValue_attribute{
        u2 attribute_name_index;	//属性名索引
        u4 attribute_length;		//属性长度
        u2 attribute_info;			//属性表
    }
  • 属性类型:

    属性名称 使用位置 含义
    Code 方法表 Java 代码编译成的字节码指令
    ConstantValue 字段表 final 关键字定义的常量池
    Deprecated 类、方法、字段表 被声明为 deprecated 的方法和字段
    Exceptions 方法表 方法抛出的异常
    EnclosingMethod 类文件 仅当一个类为局部类或者匿名类是才能拥有这个属性,这个属性用于标识这个类所在的外围方法
    InnerClass 类文件 内部类列表
    LineNumberTable Code 属性 Java 源码的行号与字节码指令的对应关系
    LocalVariableTable Code 属性 方法的局部变量描述
    StackMapTable Code 属性 JDK1.6 中新增的属性,供新的类型检查检验器检查和处理目标方法的局部变量和操作数有所需要的类是否匹配
    Signature 类,方法表,字段表 用于支持泛型情况下的方法签名
    SourceFile 类文件 记录源文件名称
    SourceDebugExtension 类文件 用于存储额外的调试信息
    Syothetic 类,方法表,字段表 标志方法或字段为编泽器自动生成的
    LocalVariableTypeTable 类 使用特征签名代替描述符,是为了引入泛型语法之后能描述泛型参数化类型而添加
    RuntimeVisibleAnnotations 类,方法表,字段表 为动态注解提供支持
    RuntimelnvisibleAnnotations 类,方法表,字段表 用于指明哪些注解是运行时不可见的
    RuntimeVisibleParameterAnnotation 方法表 作用与 RuntimeVisibleAnnotations 属性类似,只不过作用对象为方法
    RuntirmelnvisibleParameterAnniotation 方法表 作用与 RuntimelnvisibleAnnotations 属性类似,作用对象哪个为方法参数
    AnnotationDefauit 方法表 用于记录注解类元素的默认值
    BootstrapMethods 类文件 用于保存 invokeddynanic 指令引用的引导方式限定符

编译指令

javac

javac:编译命令,将 java 源文件编译成 class 字节码文件

javac xx.java 不会在生成对应的局部变量表等信息,使用 javac -g xx.java 可以生成所有相关信息


javap

javap 反编译生成的字节码文件,根据 class 字节码文件,反解析出当前类对应的 code 区 (字节码指令)、局部变量表、异常表和代码行偏移量映射表、常量池等信息

用法:javap

-help  --help  -?        输出此用法消息
-version                 版本信息
-public                  仅显示公共类和成员
-protected               显示受保护的/公共类和成员
-package                 显示程序包/受保护的/公共类和成员 (默认)
-p  -private             显示所有类和成员
						 #常用的以下三个
-v  -verbose             输出附加信息
-l                       输出行号和本地变量表
-c                       对代码进行反汇编	#反编译

-s                       输出内部类型签名
-sysinfo                 显示正在处理的类的系统信息 (路径, 大小, 日期, MD5 散列)
-constants               显示最终常量
-classpath <path>        指定查找用户类文件的位置
-cp <path>               指定查找用户类文件的位置
-bootclasspath <path>    覆盖引导类文件的位置

指令集

执行指令

Java 字节码属于 JVM 基本执行指令。由一个字节长度的代表某种操作的操作码(opcode)以及零至多个代表此操作所需参数的操作数(operand)所构成,虚拟机中许多指令并不包含操作数,只有一个操作码(零地址指令)

由于限制了 Java 虚拟机操作码的长度为一个字节(0~255),所以指令集的操作码总数不可能超过 256 条

在 JVM 的指令集中,大多数的指令都包含了其操作所对应的数据类型信息。例如 iload 指令用于从局部变量表中加载 int 型的数据到操作数栈中,而 fload 指令加载的则是 float 类型的数据

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

大部分的指令都没有支持 byte、char、short、boolean 类型,编译器会在编译期或运行期将 byte 和 short 类型的数据带符号扩展(Sign-Extend-)为相应的 int 类型数据,将 boolean 和 char 类型数据零位扩展(Zero-Extend)为相应的 int 类型数据

在做值相关操作时:

  • 一个指令,可以从局部变量表、常量池、堆中对象、方法调用、系统调用中等取得数据,这些数据(可能是值,也可能是对象的引用)被压入操作数栈
  • 一个指令,也可以从操作数栈中取出一到多个值(pop 多次),完成赋值、加减乘除、方法传参、系统调用等等操作

加载存储

加载和存储指令用于将数据从栈帧的局部变量表和操作数栈之间来回传递

局部变量压栈指令:将给定的局部变量表中的数据压入操作数栈

  • xload、xload_n,x 表示取值数据类型,为 i、l、f、d、a, n 为 0 到 3
  • 指令 xload_n 表示将第 n 个局部变量压入操作数栈,aload_n 表示将一个对象引用压栈
  • 指令 xload n 通过指定参数的形式,把局部变量压入操作数栈,局部变量数量超过 4 个时使用这个命令

常量入栈指令:将常数压入操作数栈,根据数据类型和入栈内容的不同,又分为 const、push、ldc 指令

  • push:包括 bipush 和 sipush,区别在于接收数据类型的不同,bipush 接收 8 位整数作为参数,sipush 接收 16 位整数
  • ldc:如果以上指令不能满足需求,可以使用 ldc 指令,接收一个 8 位的参数,该参数指向常量池中的 int、 float 或者 String 的索引,将指定的内容压入堆栈。ldc_w 接收两个 8 位参数,能支持的索引范围更大,如果要压入的元素是 long 或 double 类型的,则使用 ldc2_w 指令
  • aconst_null 将 null 对象引用压入栈,iconst_m1 将 int 类型常量 -1 压入栈,iconst_0 将 int 类型常量 0 压入栈

出栈装入局部变量表指令:将操作数栈中栈顶元素弹出后,装入局部变量表的指定位置,用于给局部变量赋值

  • xstore、xstore_n,x 表示取值类型为 i、l、f、d、a, n 为 0 到 3
  • xastore 表示存入数组,x 取值为 i、l、f、d、a、b、c、s

扩充局部变量表的访问索引的指令:wide


算术指令

算术指令用于对两个操作数栈上的值进行某种特定运算,并把计算结果重新压入操作数栈

没有直接支持 byte、 short、 char 和 boolean 类型的算术指令,对于这些数据的运算,都使用 int 类型的指令来处理,数组类型也是转换成 int 数组

  • 加法指令:iadd、ladd、fadd、dadd

  • 减法指令:isub、lsub、fsub、dsub

  • 乘法指令:imu、lmu、fmul、dmul

  • 除法指令:idiv、ldiv、fdiv、ddiv

  • 求余指令:irem、lrem、frem、drem(remainder 余数)

  • 取反指令:ineg、lneg、fneg、dneg (negation 取反)

  • 自增指令:iinc(直接在局部变量 slot 上进行运算,不用放入操作数栈)

  • 位运算指令,又可分为:

    • 位移指令:ishl、ishr、 iushr、lshl、lshr、 lushr
    • 按位或指令:ior、lor
    • 按位与指令:iand、land
    • 按位异或指令:ixor、lxor
  • 比较指令:dcmpg、dcmpl、 fcmpg、fcmpl、lcmp

运算模式:

  • 向最接近数舍入模式,JVM 在进行浮点数计算时,所有的运算结果都必须舍入到适当的精度,非精确结果必须舍入为可被表示的最接近的精确值,如果有两种可表示形式与该值一样接近,将优先选择最低有效位为零的
  • 向零舍入模式:将浮点数转换为整数时,该模式将在目标数值类型中选择一个最接近但是不大于原值的数字作为最精确的舍入结果

NaN 值:当一个操作产生溢出时,将会使用有符号的无穷大表示,如果某个操作结果没有明确的数学定义,将使用 NaN 值来表示

double j = i / 0.0;
System.out.println(j);//无穷大,NaN: not a number

分析 i++:从字节码角度分析:a++ 和 ++a 的区别是先执行 iload 还是先执行 iinc

 4 iload_1		//存入操作数栈
 5 iinc 1 by 1	//自增i++
 8 istore_3		//把操作数栈没有自增的数据的存入局部变量表
 9 iinc 2 by 1	//++i
12 iload_2		//加载到操作数栈
13 istore 4		//存入局部变量表,这个存入没有 _ 符号,_只能到3
public class Demo {
    public static void main(String[] args) {
        int a = 10;
        int b = a++ + ++a + a--;
        System.out.println(a);	//11
        System.out.println(b);	//34
    }
}

判断结果:

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

类型转换

类型转换指令可以将两种不同的数值类型进行相互转换,除了 boolean 之外的七种类型

宽化类型转换:

  • JVM 支持以下数值的宽化类型转换(widening numeric conversion),小范围类型到大范围类型的安全转换

    • 从 int 类型到 long、float 或者 double 类型,对应的指令为 i2l、i2f、i2d
    • 从 long 类型到 float、 double 类型,对应的指令为 l2f、l2d
    • 从 float 类型到 double 类型,对应的指令为 f2d
  • 精度损失问题

    • 宽化类型转换是不会因为超过目标类型最大值而丢失信息
    • 从 int 转换到 float 或者 long 类型转换到 double 时,将可能发生精度丢失
  • 从 byte、char 和 short 类型到 int 类型的宽化类型转换实际上是不存在的,JVM 把它们当作 int 处理

窄化类型转换:

  • Java 虚拟机直接支持以下窄化类型转换:

    • 从 int 类型至 byte、 short 或者 char 类型,对应的指令有 i2b、i2c、i2s
    • 从 long 类型到 int 类型,对应的指令有 l2i
    • 从 float 类型到 int 或者 long 类型,对应的指令有:f2i、f2l
    • 从 double 类型到 int、long 或 float 者类型,对应的指令有 d2i、d2、d2f
  • 精度损失问题:

    • 窄化类型转换可能会导致转换结果具备不同的正负号、不同的数量级,转换过程可能会导致数值丢失精度
    • 将一个浮点值窄化转换为整数类型 T(T 限于 int 或 long 类型之一)时,将遵循以下转换规则:
      • 如果浮点值是 NaN,那转换结果就是 int 或 long 类型的 0
      • 如果浮点值不是无穷大的话,浮点值使用 IEEE 754 的向零舍入模式取整,获得整数值 v,如果 v 在目标类型 T 的表示范围之内,那转换结果就是 v,否则将根据 v 的符号,转换为 T 所能表示的最大或者最小正数

创建访问

创建指令:

  • 创建类实例指令:new,接收一个操作数指向常量池的索引,表示要创建的类型,执行完成后将对象的引用压入栈

    0:  new             #2 // class com/jvm/bytecode/Demo
    3:  dup
    4:  invokespecial   #3 // Method "<init>":()V

    dup 是复制操作数栈栈顶的内容,需要两份引用原因:

    • 一个要配合 invokespecial 调用该对象的构造方法 :()V (会消耗掉栈顶一个引用)
    • 一个要配合 astore_1 赋值给局部变量
  • 创建数组的指令:newarray、anewarray、multianewarray

    • newarray:创建基本类型数组
    • anewarray:创建引用类型数组
    • multianewarray:创建多维数组

字段访问指令:对象创建后可以通过对象访问指令获取对象实例或数组实例中的字段或者数组元素

  • 访问类字段(static字段,或者称为类变量)的指令:getstatic、putstatic
  • 访问类实例字段(非static字段,或者称为实例变量)的指令:getfield、 putfield

类型检查指令:检查类实例或数组类型的指令

  • checkcast:用于检查类型强制转换是否可以进行,如果可以进行 checkcast 指令不会改变操作数栈,否则它会抛出 ClassCastException 异常

  • instanceof:判断给定对象是否是某一个类的实例,会将判断结果压入操作数栈


方法指令

方法调用指令:invokevirtual、 invokeinterface、invokespecial、invokestatic、invokedynamic

方法调用章节详解


操作数栈

JVM 提供的操作数栈管理指令,可以用于直接操作操作数栈的指令

  • pop、pop2:将一个或两个元素从栈顶弹出,并且直接废弃

  • dup、dup2,dup_x1、dup2_x1,dup_x2、dup2_x2:复制栈顶一个或两个数值并重新压入栈顶

  • swap:将栈最顶端的两个 slot 数值位置交换,JVM 没有提供交换两个 64 位数据类型数值的指令

  • nop:一个非常特殊的指令,字节码为 0x00,和汇编语言中的 nop 一样,表示什么都不做,一般可用于调试、占位等


控制转移

比较指令:比较栈顶两个元素的大小,并将比较结果入栈

  • lcmp:比较两个 long 类型值
  • fcmpl:比较两个 float 类型值(当遇到NaN时,返回-1)
  • fcmpg:比较两个 float 类型值(当遇到NaN时,返回1)
  • dcmpl:比较两个 double 类型值(当遇到NaN时,返回-1)
  • dcmpg:比较两个 double 类型值(当遇到NaN时,返回1)

条件跳转指令:

指令 说明
ifeq equals,当栈顶int类型数值等于0时跳转
ifne not equals,当栈顶in类型数值不等于0时跳转
iflt lower than,当栈顶in类型数值小于0时跳转
ifle lower or equals,当栈顶in类型数值小于等于0时跳转
ifgt greater than,当栈顶int类型数组大于0时跳转
ifge greater or equals,当栈顶in类型数值大于等于0时跳转
ifnull 为 null 时跳转
ifnonnull 不为 null 时跳转

比较条件跳转指令:

指令 说明
if_icmpeq 比较栈顶两 int 类型数值大小(下同),当前者等于后者时跳转
if_icmpne 当前者不等于后者时跳转
if_icmplt 当前者小于后者时跳转
if_icmple 当前者小于等于后者时跳转
if_icmpgt 当前者大于后者时跳转
if_icmpge 当前者大于等于后者时跳转
if_acmpeq 当结果相等时跳转
if_acmpne 当结果不相等时跳转

多条件分支跳转指令:

  • tableswitch:用于 switch 条件跳转,case 值连续
  • lookupswitch:用于 switch 条件跳转,case 值不连续

无条件跳转指令:

  • goto:用来进行跳转到指定行号的字节码

  • goto_w:无条件跳转(宽索引)


异常处理
处理机制

抛出异常指令:athrow 指令

JVM 处理异常(catch 语句)不是由字节码指令来实现的,而是采用异常表来完成的

  • 代码:

    public static void main(String[] args) {    
        int i = 0;    
        try {    	
            i = 10;    
        } catch (Exception e) {   
            i = 20;   
        } finally {
            i = 30;
        }
    }
  • 字节码:

    • 多出一个 Exception table 的结构,[from, to) 是前闭后开的检测范围,一旦这个范围内的字节码执行出现异常,则通过 type 匹配异常类型,如果一致,进入 target 所指示行号
    • 11 行的字节码指令 astore_2 是将异常对象引用存入局部变量表的 slot 2 位置,因为异常出现时,只能进入 Exception table 中一个分支,所以局部变量表 slot 2 位置被共用
        0: 	iconst_0
        1: 	istore_1 	// 0 -> i	->赋值
        2: 	bipush 10 	// try 10 放入操作数栈顶
        4: 	istore_1 	// 10 -> i 将操作数栈顶数据弹出,存入局部变量表的 slot1
        5: 	bipush 30 	// 【finally】 
        7: 	istore_1 	// 30 -> i 
        8: 	goto 27 	// return -----------------------------------
        11: astore_2 	// catch Exceptin -> e ----------------------
        12: bipush 20 	// 
        14: istore_1 	// 20 -> i 
        15: bipush 30 	// 【finally】 
        17: istore_1 	// 30 -> i 
        18: goto 27 	// return -----------------------------------
        21: astore_3 	// catch any -> slot 3 ----------------------
        22: bipush 30 	// 【finally】
        24: istore_1 	// 30 -> i 
        25: aload_3 	// 将局部变量表的slot 3数据弹出,放入操作数栈栈顶
        26: athrow 		// throw 抛出异常
        27: return
    Exception table:
    	// 任何阶段出现任务异常都会执行 finally
    	from   to 	target 	type
    		2	5 		11 	Class java/lang/Exception
    		2 	5 		21 	any // 剩余的异常类型,比如 Error
    		11 15 		21 	any // 剩余的异常类型,比如 Error
    LineNumberTable: ...
    LocalVariableTable:
    	Start Length Slot Name Signature
    	12 		3 		2 	e 	Ljava/lang/Exception;
    	0 		28 		0 args 	[Ljava/lang/String;
    	2 		26 		1 	i 	I

finally

finally 中的代码被复制了 3 份,分别放入 try 流程,catch 流程以及 catch 剩余的异常类型流程(上节案例)

  • 代码:

    public static int test() {
        try {
        	return 10;
        } finally {
        	return 20;
        }
    }
  • 字节码:

        0: bipush 10 	// 10 放入栈顶
        2: istore_0 	// 10 -> slot 0 【从栈顶移除了】
        3: bipush 20 	// 20 放入栈顶
        5: ireturn 		// 返回栈顶 int(20)
        6: astore_1 	// catch any 存入局部变量表的 slot1
        7: bipush 20 	// 20 放入栈顶
        9: ireturn 		// 返回栈顶 int(20)
    Exception table:
    	from   to 	target 	type
    		0	3		6 	any      

return
  • 吞异常

    public static int test() {
        try {
        	return 10;
        } finally {
        	return 20;
        }
    }
        0: bipush 10 	// 10 放入栈顶
        2: istore_0 	// 10 -> slot 0 【从栈顶移除了】
        3: bipush 20 	// 20 放入栈顶
        5: ireturn 		// 返回栈顶 int(20)
        6: astore_1 	// catch any  存入局部变量表的 slot1
        7: bipush 20 	// 20 放入栈顶
        9: ireturn 		// 返回栈顶 int(20)
    Exception table:
    	from   to 	target 	type
    		0	3		6 	any      
    • 由于 finally 中的 ireturn 被插入了所有可能的流程,因此返回结果以 finally 的为准
    • 字节码中没有 athrow ,表明如果在 finally 中出现了 return,会吞掉异常
  • 不吞异常

    public class Demo {
        public static void main(String[] args) {
        	int result = test();
        	System.out.println(result);//10
    	}
    	public static int test() {
            int i = 10;
            try {
                return i;//返回10
            } finally {
                i = 20;
            }
       	}
    }
        0: 	bipush 10 	// 10 放入栈顶
        2: 	istore_0 	// 10 赋值给i,放入slot 0
        3: 	iload_0 	// i(10)加载至操作数栈
        4: 	istore_1 	// 10 -> slot 1,【暂存至 slot 1,目的是为了固定返回值】
        5: 	bipush 20 	// 20 放入栈顶
        7: 	istore_0 	// 20 slot 0
        8: 	iload_1 	// slot 1(10) 载入 slot 1 暂存的值
        9: 	ireturn 	// 返回栈顶的 int(10)
        10: astore_2	// catch any -> slot 2 存入局部变量表的 slot2
        11: bipush 20
        13: istore_0
        14: aload_2
        15: athrow		// 不会吞掉异常
    Exception table:
    	from   to 	target 	type
    	  3	   5		10 	any  

同步控制

方法级的同步:是隐式的,无须通过字节码指令来控制,它实现在方法调用和返回操作之中,虚拟机可以从方法常量池的方法表结构中的 ACC_SYNCHRONIZED 访问标志得知一个方法是否声明为同步方法

方法内指定指令序列的同步:有 monitorenter 和 monitorexit 两条指令来支持 synchronized 关键字的语义

  • montiorenter:进入并获取对象监视器,即为栈顶对象加锁
  • monitorexit:释放并退出对象监视器,即为栈顶对象解锁

执行流程

原始 Java 代码:

public class Demo {	
    public static void main(String[] args) {        
        int a = 10;        
        int b = Short.MAX_VALUE + 1;        
        int c = a + b;        
        System.out.println(c);	
    }
}

javap -v Demo.class:省略

  • 常量池载入运行时常量池

  • 方法区字节码载入方法区

  • main 线程开始运行,分配栈帧内存:(操作数栈stack=2,局部变量表locals=4)

  • 执行引擎开始执行字节码

    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:将操作数栈顶数据弹出,存入局部变量表的 slot 2

    iload_1:将局部变量表的 slot 1 数据弹出,放入操作数栈栈顶

    iload_2:将局部变量表的 slot 2 数据弹出,放入操作数栈栈顶

    iadd:执行相加操作

    istore_3:将操作数栈顶数据弹出,存入局部变量表的 slot 3

    getstatic #4:获取静态字段

    iload_3:

    invokevirtual #5:

    • 找到常量池 #5 项
    • 定位到方法区 java/io/PrintStream.println:(I)V 方法
    • 生成新的栈帧(分配 locals、stack等)
    • 传递参数,执行新栈帧中的字节码
    • 执行完毕,弹出栈帧
    • 清除 main 操作数栈内容

    return:完成 main 方法调用,弹出 main 栈帧,程序结束