Java 字节码简介

Java 中的字节码，英文名为 bytecode, 是 Java 代码编译后的中间代码格式。JVM 需要读取并解析字节码才能执行相应的任务。

从技术人员的角度看，Java 字节码是 JVM 的指令集。JVM 加载字节码格式的 class 文件，校验之后通过 JIT 编译器转换为本地机器代码执行。 Java 字节码就是 JVM 执行的指令格式。

Java bytecode 由单字节(byte)的指令组成，理论上最多支持 256 个操作码(opcode)。实际上 Java 只使用了 200 左右的操作码， 还有一些操作码则保留给调试操作。

操作码， 下面称为 指令, 主要由类型前缀和操作名称两部分组成。

例如，’i’ 前缀代表 ‘integer’，所以，’iadd’ 很容易理解， 表示对整数执行加法运算。

根据指令的性质，主要分为四个大类：

1. 栈操作指令，包括与局部变量交互的指令
2. 程序流程控制指令
3. 对象操作指令，包括方法调用指令
4. 算术运算以及类型转换指令

此外还有一些执行专门任务的指令，比如同步(synchronization)指令，以及抛出异常相关的指令等等。

获取字节码清单

可以用 javap 工具来获取 class 文件中的指令清单。 javap 是标准 JDK 内置的一款工具, 专门用于反编译 class 文件。

先创建一个简单的类仅创建一个对象，后续慢慢扩充。

package com.lkl.jvmDemo;

public class HelloByteCode {
    public static void main(String[] args) {
        HelloByteCode obj = new HelloByteCode();
    }
}

编译这个类：

javac HelloByteCode.java

使用 javac 编译 ，直接在当前目录执行上述指令，得到对应的 class 即可。

javac 不指定 -d 参数编译后生成的 .class 文件默认和源代码在同一个目录。

注意: javac 工具默认开启了优化功能, 生成的字节码中没有局部变量表(LocalVariableTable)，相当于局部变量名称被擦除。如果需要这些调试信息, 在编译时请加上 -g 选项。

JDK 自带工具的详细用法, 请使用: javac -help 或者 javap -help 来查看; 其他类似。

使用 javap 工具来执行反编译， 获取字节码清单：

还是在上述目录，执行下面指令：

javap -c HelloByteCode

或者

javap -c HelloByteCode.class

编译结果如下：

Compiled from "HelloByteCode.java"
public class com.lkl.jvmDemo.HelloByteCode {
  public com.lkl.jvmDemo.HelloByteCode();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #7                  // class com/lkl/jvmDemo/HelloByteCode
       3: dup
       4: invokespecial #9                  // Method "<init>":()V
       7: astore_1
       8: return
}

解读字节码清单

反编译后的代码清单中, 有一个默认的构造函数 public com.lkl.jvmDemo.HelloByteCode(), 以及 main 方法。

Java基础中，创建一个类如果不定义任何构造函数，就会有一个默认的无参构造函数，这里再次验证了这个知识点。查看编译后的 class 文件证实了其中存在默认构造函数，所以这是 Java 编译器生成的， 而不是运行时JVM自动生成的。

默认构造函数一些指令

回顾 Java 知识, 每个构造函数中都会先调用 super 类的构造函数，但这不是 JVM 自动执行的, 而是由程序指令控制，所以默认构造函数中也就有一些字节码指令来干这个事情。

基本上，这几条指令就是执行 super() 调用：

public com.lkl.jvmDemo.HelloByteCode();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

其中解析的 java/lang/Object 不用说， 默认继承了 Object 类。这里再次验证了这个知识点，而且这是在编译期间就确定了的。

main函数指令

 public static void main(java.lang.String[]);
    Code:
       0: new           #7                  // class com/lkl/jvmDemo/HelloByteCode
       3: dup
       4: invokespecial #9                  // Method "<init>":()V
       7: astore_1
       8: return

main 方法中创建了该类的一个实例， 然后就 return了，关于里面的几个指令， 稍后讲解。

查看 class 文件中的常量池信息

常量池 英文是 Constant pool。这里做一个强调：大多数时候指的是 运行时常量池。但运行时常量池里面的常量是从哪里来的呢? 主要就是由 class 文件中的 常量池结构体 组成的。

要查看常量池信息，需要加一点魔法参数:

javap -c -verbose HelloByteCode

在反编译 class 时，指定 -verbose 选项, 则会 输出附加信息。

Classfile /XXX/com/lkl/jvmDemo/HelloByteCode.class
  Last modified 2023-10-29; size 304 bytes
  MD5 checksum 565e4ca34e83f69df37c1f35c971375f
  Compiled from "HelloByteCode.java"
public class com.lkl.jvmDemo.HelloByteCode
  minor version: 0
  major version: 65
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Class              #8             // com/lkl/jvmDemo/HelloByteCode
   #8 = Utf8               com/lkl/jvmDemo/HelloByteCode
   #9 = Methodref          #7.#3          // com/lkl/jvmDemo/HelloByteCode."<init>":()V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               main
  #13 = Utf8               ([Ljava/lang/String;)V
  #14 = Utf8               SourceFile
  #15 = Utf8               HelloByteCode.java
{
  public com.lkl.jvmDemo.HelloByteCode();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: new           #7                  // class com/lkl/jvmDemo/HelloByteCode
         3: dup
         4: invokespecial #9                  // Method "<init>":()V
         7: astore_1
         8: return
      LineNumberTable:
        line 5: 0
        line 6: 8
}

显示了很多关于 class 文件信息： 编译时间， MD5 校验和， 从哪个 .java 源文件编译得来，符合哪个版本的 Java 语言规范等等。

还可以看到 ACC_PUBLIC 和 ACC_SUPER 访问标志符。 ACC_PUBLIC 标志很容易理解：这个类是 public 类，因此用这个标志来表示。

但 ACC_SUPER 标志是怎么回事呢？ 这就是历史原因, JDK 1.0 的 BUG 修正中引入 ACC_SUPER 标志来修正 invokespecial 指令调用 super 类方法的问题，从 Java 1.1 开始， 编译器一般都会自动生成ACC_SUPER 标志。

摘取一部分内容，可以看到常量池中的常量定义。还可以进行组合，一个常量的定义中可以引用其他常量。

Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>

第一行: #1 = Methodref #2.#3 // java/lang/Object."<init>":()V, 解读如下:

• #1 常量编号, 该文件中其他地方可以引用。
• = 等号就是分隔符.
• Methodref 表明这个常量指向的是一个方法；具体是哪个类的哪个方法呢? 类指向的 #2, 方法签名指向的 #3; 当然双斜线注释后面已经解析出来可读性比较好的说明了。

总结一下，常量池就是一个常量的大字典，使用编号的方式把程序里用到的各类常量统一管理起来，这样在字节码操作里，只需要引用编号即可。

查看方法信息

在 javap 命令中使用 -verbose 选项时， 还显示了其他的一些信息。 例如， 关于 main 方法的更多信息被打印出来：

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1

可以看到方法描述: ([Ljava/lang/String;)V：

• 其中小括号内是入参信息/形参信息；
• 左方括号表述数组；
• L 表示对象；
• 后面的java/lang/String就是类名称；
• 小括号后面的 V 则表示这个方法的返回值是 void；
• 方法的访问标志也很容易理解 flags: ACC_PUBLIC, ACC_STATIC，表示 public 和 static。

可以看到执行该方法时需要的栈(stack)深度是多少，需要在局部变量表中保留多少个槽位, 还有方法的参数个数: stack=2, locals=2, args_size=1。把上面这些整合起来其实就是一个方法：

public static void main(java.lang.String[]);

注：实际上一般把一个方法的修饰符+名称+参数类型清单+返回值类型，合在一起叫“方法签名”，即这些信息可以完整的表示一个方法。

编译器自动生成的无参构造函数字节码：

 public com.lkl.jvmDemo.HelloByteCode();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1

会发现一个奇怪的地方, 无参构造函数的参数个数居然不是 0: stack=1, locals=1, args_size=1。 这是因为在 Java 中, 如果是静态方法则没有 this 引用。 对于非静态方法， this 将被分配到局部变量表的第 0 号槽位中。

线程栈与字节码执行模型

JVM 是一台基于栈的计算机器。每个线程都有一个独属于自己的线程栈(JVM stack)，用于存储栈帧(Frame)。每一次方法调用，JVM都会自动创建一个栈帧。栈帧 由 操作数栈， 局部变量数组 以及一个class 引用组成。class 引用 指向当前方法在运行时常量池中对应的 class)。

局部变量数组就是局部变量表(LocalVariableTable), 其中包含了方法的参数，以及局部变量。 局部变量数组的大小在编译时就已经确定: 和局部变量+形参的个数有关，还要看每个变量/参数占用多少个字节。操作数栈是一个 LIFO 结构的栈， 用于压入和弹出值。 它的大小也在编译时确定。