字节码指令集与解析举例

_

• 比如：
  • iconst_m1 将 -1 压入操作数栈
  • iconst_x（x 为 0 到 5）将 x 压入栈
  • lconst_0、lconst_1 分别将长整数 0 和 1 压入栈
  • fconst_0、fconst_1、fconst_2 分别将浮点数 0、1、2 压入栈
  • dconst_0 和dconst_1 分别将 double 型 0 和 1 压入栈
  • aconst_null 将 null 压入操作数栈

• 从指令的命名上不难找出规律，指令助记符的第一个字符总是喜欢表示数据类型，i 表示整数，l 表示长整型，f 表示浮点数，d 表示双精度浮点，习惯上用 a 表示对象引用。如果指令隐含操作的参数，会以下划线形式给出。

• 指令 push 系列：主要包括 bipush 和 sipush，它们的区别在于接受数据类型的不同，bipush 接收 8 位整数作为参数，sipush 接收 16 位整数，它们都将参数压入栈。

• 指令 ldc 系列：如果以上指令都不能满足需求，那么可以使用万能的ldc指令，它可以接收一个 8 位的参数，该参数指向常量池中的 int、float 或者 String 的索引，将指定的内容压入堆栈。

• 类似的还有ldc_w，它接收两个 8 位参数，能支持的索引范围大于 ldc

• 如果要压入的元素是 long 或者 double 类型的，则使用ldc2_w 指令，使用方式都是类似的。

• (由于常量入栈指令非常简单，具体演示直接看代码，然后jclasslib查看即可)

    //2.常量入栈指令
    public void pushConstLdc() {
        int i = -1;
        int a = 5;
        int b = 6;
        int c = 127;
        int d = 128;
        int e = 32767;
        int f = 32768;
    }
    public void constLdc() {
        long a1 = 1;
        long a2 = 2;
        float b1 = 2;
        float b2 = 3;
        double c1 = 1;
        double c2 = 2;
        Date d = null;
    }

  

• 总结如下：

出栈装入局部变量表指令

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

• 这类指令主要以 store 的形式存在，比如 xstore（x 为 i、l、f、d、a）、xstore_n（x 为 i、l、f、d、a，n 为 0 至 3）。

  • 其中，指令istore_n 将从操作数栈中弹出一个整数，并把它赋值给局部变量索引 n 位置。
  • 指令 xstore 由于没有隐含参数信息，故需要提供一个 byte 类型的参数类指定目标局部变量表的位置。

• xastore 则专门针对数组操作，以 iastore 为例，它用于给一个 int 数组的给定索引赋值。在 iastore 执行前，操作数栈顶需要以此准备3个元素：值、索引、数组引用，iastore 会弹出这3个值，并将值赋给数组中指定索引的位置。

说明：

• 一般说来，类似像 store 这样的命令需要带一个参数，用来指明将弹出的元素放在局部变量表的第几个位置。但是，为了尽可能压缩指令大小，使用专门的 istore_1 指令表示将弹出的元素放置在局部变量表第 1 个位置。类似的还有 istore_0、istore_2、istore_3，它们分别表示从操作数栈顶弹出一个元素，存放在局部变量表第 0、2、3 个位置。

• 由于局部变量表前几个位置总是非常常用，因此这种做法虽然增加了指令数量，但是可以大大压缩生成的字节码的体积。如果局部变量表很大，需要存储的槽位大于 3，那么可以使用 istore 指令，外加一个参数，用来表示需要存放的槽位位置。 ```java //3.出栈装入局部变量表指令 public void store(int k, double d) {

    int m = k + 2;
    long l = 12;
    String str = "atguigu";
    float f = 10.0F;
    d = 10;

  }

注意：局部变量表存放的是实际数据，而不是引用；操作栈中的数放到局部变量表中就出栈了，不会如图叠加
> [https://www.bilibili.com/video/BV1PJ411n7xZ?p=244&spm_id_from=pageDriver](https://www.bilibili.com/video/BV1PJ411n7xZ?p=244&spm_id_from=pageDriver)

![image.png](https://cdn.nlark.com/yuque/0/2021/png/12731578/1617782417464-e92653e1-490b-4db9-acdc-4f0c8ff3eb62.png#align=left&display=inline&height=317&margin=%5Bobject%20Object%5D&name=image.png&originHeight=633&originWidth=1485&size=353484&status=done&style=none&width=742.5)

---

<a name="vNBjV"></a>
## 算术指令

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

- 分类:
   - 大体上算术指令可以分为两种：对整型数据进行运算的指令与对浮点型类型数据进行运算的指令。

- byte、short、char 和 boolean 类型说明
   - 在每一大类中，都有针对 Java 虚拟机具体数据类型的专用算术指令。但没有直接支持 byte、short、char 和 boolean 类型的算术指令，对于这些数据的运算，都使用 int 类型的指令来处理。此外，在处理 boolean、byte、short 和 char 类型的数组时，也会转换为使用对应的 int 类型的字节码指令来处理。

![image.png](https://cdn.nlark.com/yuque/0/2021/png/12731578/1617783059638-ddd90ca5-4b89-434a-859e-fa9013a18625.png#align=left&display=inline&height=302&margin=%5Bobject%20Object%5D&name=image.png&originHeight=402&originWidth=1013&size=129124&status=done&style=none&width=760)

- 运算时的溢出
   - 数据运算可能会导致溢出，例如两个很大的正整数相加，结果可能是一个负数。其实 Java 虚拟机规范并无明确规定过整型数据溢出的具体结果，仅规定了在处理整型数据时，只有除法指令以及求余指令中当出现除数为 0 时会导致虚拟机抛出异常 ArithmeticException。

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

- NaN 值使用
   - 当一个操作产生溢出时，将会使用有符号的无穷大表示，如果某个操作结果没有明确的数学定义的话，将会使用 NaN（Not a Number） 值来表示。而且所有使用 NaN 值作为操作数的算术操作，结果都会返回 NaN。
   - 如 0.0/0.0

- Infinity 无穷大
   - 如 10 / 0.0
```java
    @Test
    public void method1(){
        int i = 10;
        double j = i / 0.0;
        System.out.println(j);//无穷大


        double d1 = 0.0;
        double d2 = d1 / 0.0;
        System.out.println(d2);//NaN: not a number
    }

所有算术指令

• 加法指令：iadd、ladd、fadd、dadd
• 减法指令：isub、lsub、fsub、dsub
• 乘法指令：imul、lmul、fmul、dmul
• 除法指令：idiv、ldiv、fdiv、ddiv
• 求余指令：irem、lrem、frem、drem //remainder：余数
• 取反指令：ineg、lneg、fneg、dneg //negation：取反
• 自增指令：iinc
• 位运算指令，又可分为：
  • 位移指令：ishl、ishr、iushr、lshl、lshr、lushr
  • 按位或指令：ior、lor
  • 按位与指令：iand、land
  • 按位异或指令：ixor、lxor
• 比较指令：dcmpg、dcmlp、fcmpg、fcmpl、lcmp

举例：

    public void method2(){
        float i = 10;
        float j = -i;
        i = -j;
    }

    public void method3(int j){
        int i = 100;
        i = i + 10;
//        i += 10;
    }

   public int method4(){
        int a = 80;
        int b = 7;
        int c = 10;
        return (a + b) * c;
    }

    public int method5(int i ,int j){
        return ((i + j - 1) & ~(j - 1));
    }

取反操作：源码与-1做异或操作

    //关于(前)++和(后)++
    public void method6(){
        int i = 10;
        i++;
//        ++i;

//        for(int j = 0;j < 10;j++){}
    }

    public void method7(){
        int i = 10;
        int a = i++;

        int j = 20;
        int b = ++j;
    }

10先入栈，出栈到局部变量表，再通过iload入栈 ，此时局部变量表和栈顶都为10，自增是在局部变量表执行，栈顶元素存到索引为2的位置，即a。

    //思考
    public void method8(){
        int i = 10;
        i = i++;
        System.out.println(i);//10
    }

总结：先++和后++的区别在于加载到操作数栈中的时机

public static int bar(int i) {
  return ((i + 1) - 2) * 3 / 4;
}

字节码指令对应的图示：

比较指令的说明

• 比较指令的作用是比较栈顶两个元素的大小，并将比较结果入栈。

• 比较指令有：dcmpg、dcmpl、fcmpg、fcmpl、lcmp

  • 与前面讲解的指令类似，首字符 d 表示 double 类型，f 表示 float，l 表示 long

• 对于 double 和 float 类型的数字，由于 NaN 的存在，各有两个版本的比较指令。
  以 float 为例，有 fcmpg 和 fcmpl 两个指令，它们的区别在于在数字比较时，若遇到 NaN 值，处理结果不同。

• 指令 dcmpl 和 dcmpg 也是类似的，根据其命名可以推测其含义。

• 指令 lcmp 针对 long 型整数，由于 long 型整数没有 NaN 值，故无需准备两套指令。

举例：

• 指令 fcmpg 和 fcmpl 都从栈中弹出两个操作数，并将它们做比较，设栈顶的元素为 v2， 栈顶顺位第 2 位元素为 v1，若 v1 = v2，则压入 0；若 v1 > v2 则压入 1；若 v1

• 两个指令的不同之处在于，如果遇到 NaN 值，fcmpg 会压入 1，而 fcmpl 会压入 -1。

类型转换指令

类型转换指令说明

• 类型转换指令可以将两种不同的数值类型进行相互转换。
• 这些转换操作一般用于实现用户代码中的显式类型转换操作，或者用来处理字节码指令集中数据类型相关指令无法与数据类型一一对应的问题。

宽化类型转换（Widening Numeric Conversions）

转换规则

• Java 虚拟机直接支持以下数值的宽化类型转换（Widening Numeric Conversion，小范围类型向大范围类型的安全转换）。也就是说，并不需要指令执行，包括：
  • 从 int 类型到 long、float 或者 double 类型。对应的指令为：i2l、i2f、i2d
  • 从 long 类型到 float、double 类型。对应的指令为：l2f、l2d
  • 从 flaot 类型到 double 类型。对应的指令为：f2d

• 简化为：int —> long —> float —> double

   //宽化类型转换
  
    //针对于宽化类型转换的基本测试
    public void upCast1(){
        int i  = 10;
        long l = i;
        float f = i;
        double d = i;
  
        float f1 = l;
        double d1 = l;
  
        double d2 = f1;
    }
  

  
  精度损失问题

• 宽化类型转换是不会因为超过目标类型最大值而丢失信息的，例如，从 int 转换到 long，或者从 int 转换到 double，都不会丢失任何信息，转换前后的值是精确相等的。

• 从 int、long 类型数值转换到 float，或者 long 类型树脂转换到 double 时，将可能发生丢失精度 —— 可能丢失掉几个最低有效位上的值，转换后的浮点数值是根据 IEEE754 最接近舍入模式所得到的正确整数数值。

• 尽管宽化类型转换实际上是可能发生精度丢失的，但是这种转换永远不会导致 Java 虚拟机抛出运行时异常。 ```java //举例：精度损失的问题 @Test public void upCast2(){

    int i = 123123123;
    float f = i;
    System.out.println(f);//123123120
  
    long l = 123123123123L;
    l = 123123123123123123L;
    double d = l;
    System.out.println(d);//123123123123123120
  

  }

**补充说明**

- 从 byte、char 和 short 类型到 int 类型的宽化类型转换实际上是不存在的。对于 byte 类型转换为 int，虚拟机并没有做实质性的转化处理，只是简单地通过操作数栈交换了两个数据。而 byte 转为 long 时，使用的是 i2l，可以看到在内部 byte 在这里已经等同于 int 类型处理，类似的还有 short 类型，这种处理方式有两个特点：
   - 一方面可以减少实际的数据类型，如果为 short 和 byte 都准备一套指令，那么指令的数量就会大增，而虚拟机目前的设计上，只愿意使用一个字节表示指令，因此指令总数不能超过 256 个，为了节省指令资源，将 short 和 byte 当作 int 处理也是情理之中。
   - 另一方面，由于局部变量表中的槽位固定为 32 位，无论是 byte 或者 short 存入局部变量表，都会占用 32 位空间。从这个角度来说，也没有必要特意区分这几种数据类型。
```java
    //针对于byte、short等转换为容量大的类型时，将此类型看做int类型处理。
    public void upCast3(byte b){
        int i = b;
        long l = b;
        double d = b;
    }

窄化类型转换

转换规则

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

  • 从 int 类型至 byte、short 或者 char 类型。对应的指令有：i2b、i2s、i2c
  • 从 long 类型到 int 类型。对应的指令有：l2i
  • 从 float 类型到 int 或者 long 类型。对应的指令有：f2i、f2l
  • 从 double 类型到 int、long 或者 float 类型。对应的指令有：d2i、d2l、d2f

  • 从 long 类型到 byte 类型。l2i => i2b

    //窄化类型转换
    //基本的使用
    public void downCast1(){
       int i = 10;
       byte b = (byte)i;
       short s = (short)i;
       char c = (char)i;
    
       long l = 10L;
       int i1 = (int)l;
       byte b1 = (byte) l;
    }
    

    
    精度损失问题

• 窄化类型转换可能会导致转换结果具备不同的正负号、不同的数量级，因此，转换过程很可能会导致数值丢失精度。

• 尽管数据类型窄化转换可能会发生上限溢出、下限溢出和精度丢失等情况，但是 Java 虚拟机规范中明确规定数值类型的窄化转换指令永远不可能导致虚拟机抛出运行时异常。

    //窄化类型转换的精度损失
    @Test
    public void downCast4(){
        int i = 128;
        byte b = (byte)i;
        System.out.println(b);//-128
    }
  

  
  补充说明

• 当一个浮点值窄化转换为整数类型 T（T 限于 int 或 long 类型之一）的时候，将遵循以下转换规则：

  • 如果浮点值是 NaN，那转换结果就是 int 或 long 类型的 0。
  • 如果浮点值不是无穷大的话，浮点值使用 IEEE754 的向零舍入模式取整，获得整数值 v，如果 v 在目标类型 T（int 或 long）的表示范围之内，那转换结果就是 v。否则，将根据 v 的符号，转换为 T 所能表示的最大或者最小正数。（MAX_VALUE）

• 当一个 double 类型窄化转换为 float 类型时，将遵循以下转换规则：

  • 通过向最接近数舍入模式舍入一个可以使用 float 类型表示的数字。最后结果根据下面这 3 条规则判断：
  • 如果转换结果的绝对值太小而无法使用 float 来表示，将返回 float 类型的正负零。
  • 如果转换结果的绝对值太大而无法使用 float 来表示，将返回 float 类型的正负无穷大。

  • 对于 double 类型的 NaN 值将按规定转换为 float 类型的 NaN 值。

    //测试NaN,无穷大的情况
    @Test
    public void downCast5(){
       double d1 = Double.NaN; //0.0 / 0.0
       int i = (int)d1;
       System.out.println(d1);
       System.out.println(i);
    
       double d2 = Double.POSITIVE_INFINITY;
       long l = (long)d2;
       int j = (int)d2;
       System.out.println(l);
       System.out.println(Long.MAX_VALUE);
       System.out.println(j);
       System.out.println(Integer.MAX_VALUE);
    
       float f = (float)d2;
       System.out.println(f);
    
       float f1 = (float)d1;
       System.out.println(f1);
    }
    

    

对象的创建与访问指令

Java是面向对象的程序设计语言。虚拟机平台从字节码层面就对面向对象做了深层次的支持。有一系列指令专门用于对象操作，可进一步细分为创建指令、字段访问指令、数组操作指令、类型检查指令。

创建指令

虽然类实例和数组都是对象。但Java虚拟机对类实例和数组的创建与操作使用了不同的字节码指令:

创建类实例的指令：

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

创建数组的指令：

• 创建数组的指令: newarray，anewarray，multianewarray
  • newarray：创建基本类型数组
  • anewarray：创建引用类型数组
  • multianewarray：创建多维数组

• 上述创建指令可以用于创建对象或者数组。由于对象和数组在Java中的广泛使用，这些指令的使用频率也非常高。

    //1.创建指令
    public void newInstance() {
        Object obj = new Object();
  
        File file = new File("atguigu.avi");
    }
   public void newArray() {
        int[] intArray = new int[10];
        Object[] objArray = new Object[10];
        int[][] mintArray = new int[10][10];
  
        String[][] strArray = new String[10][];
    }
  

  **
  

  字段访问指令

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

• 访问类字段(static字段， 或者称为类变量)的指令: getstatic（把相应的字段压入到操作数栈中）、 putstatic（把操作数栈的值弹出来并做赋值）

• 访问类实例字段(非static字段， 或者称为实例变量)的指令: getfield（把相应的字段压入到操作数栈中）、 putfield（把操作数栈的值弹出来并做赋值）

举例:

• 以getstatic指令为例，它含有一个操作数，为指向常量池的Fieldref索引，它的作用就是获取Fieldref指定的对象或者值，并将其压入操作数栈。

   //2.字段访问指令
    public void sayHello() {
        System.out.println("hello");
    }
  

  
  

数组操作指令

数组操作指令主要有: xastore 和xaload指令。具体为:

• 把一个数组元素加载到操作数栈的指令: baload、caload、 saload、iaload、laload、faload、daload、aaload

• 将一个操作数栈的值存储到数组元素中的指令：bastore、castore、sastore、 iastore、lastore、fastore、dastore、aastore（修改的是堆中的值）

即:

• 
• 取数组长度的指令: arraylength
  • 该指令弹出栈顶的数组，获取数组的长度，将长度压入栈。

说明

• 指令xaload表示将数组的元素压栈，比如saload、 caload分别表示压入short数组和char数组。指令xaload在执行时，要求操作数中栈顶元素为数组索引i,栈顶顺位第2个元素为数组引用a,该指令会弹出栈顶这两个元素，并将a[i]重新压入堆栈。

• xastore则专门针对数组操作，以iastore为例， 它用于给一个int 数组的给定索引赋值。在iastore执行前，操作数栈顶需要以此准备3个元素:值、索引、数组引用，iastore 会弹出这3个值，并将值赋给数组中指定索引的位置

    //3.数组操作指令
    public void setArray() {
        int[] intArray = new int[10];
        intArray[3] = 20;
        System.out.println(intArray[1]);
  
        boolean[] arr = new boolean[10];
        arr[1] = true;
    }
    public void arrLength(){
  
        double[] arr = new double[10];
        System.out.println(arr.length);
    }
  

  0 bipush 10
  2 newarray 10 (int)
  4 astore_1
  5 aload_1
  6 iconst_3
  7 bipush 20
  9 iastore
  10 getstatic #8 <java/lang/System.out>
  13 aload_1
  14 iconst_1
  15 iaload
  16 invokevirtual #14 <java/io/PrintStream.println>
  19 bipush 10
  21 newarray 4 (boolean)
  23 astore_2
  24 aload_2
  25 iconst_1
  26 iconst_1
  27 bastore
  28 return
  

  

类型检查指令

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

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

• 指令instanceof用来判断给定对象是否是某一个类的实例，它会将判断结果压入操作数栈。

    //4.类型检查指令
    public String checkCast(Object obj) {
        if (obj instanceof String) {
            return (String) obj;
        } else {
            return null;
        }
    }
  

  0 aload_1
  1 instanceof #17 <java/lang/String>
  4 ifeq 12 (+8)
  7 aload_1
  8 checkcast #17 <java/lang/String>
  11 areturn
  12 aconst_null
  13 areturn
  

方法调用与返回指令

方法调用指令

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

以下5条指令用于方法调用:

• invokevirtual指令用于调用对象的实例方法，根据对象的实际类型进行分派(虚方法分派) ，支持多态。这也是Java语言中最常见的方法分派方式。

• invokeinterface指令用于调用接口方法，它会在运行时搜索由特定对象所实现的这个接口方法，井找出适合的方法进行调用。

• invokespecial指令用于调用一些需要特殊处理的实例方法， 包括实例初始化方法(构造器)、私有方法和父类方法。这些方法都是静态类型绑定的，不会在调用时进行动态派发。(这三个方法不会被重写）

• invokestatic指令用于调用命名类中的类方法(static方法) 。这是静态绑定的。

• invokedynamic 调用动态绑定的方法，这个是JDK 1. 7后新加入的指令。用于在运行时动态解析出调用点限定符所引用的方法，并执行该方法。前面4条调用指令的分派逻辑都因化在java虚拟机内部，而invokedynamic指令的分派逻辑是由用户所设定的引导方法决定的。

    //方法调用指令:invokespecial:静态分派
    public void invoke1(){
        //情况1：类实例构造器方法：<init>()
        Date date = new Date();
  
        Thread t1 = new Thread();
        //情况2：父类的方法
        super.toString();
        //情况3：私有方法
        methodPrivate();
    }
    private void methodPrivate(){
  
    }
  

  ```java 0 new #2 3 dup 4 invokespecial #3 > 7 astore_1 8 new #4 11 dup 12 invokespecial #5 > 15 astore_2 16 aload_0 17 invokespecial #6 20 pop 21 aload_0 22 invokespecial #7 25 return

```java
    //方法调用指令:invokestatic:静态分派
    public void invoke2(){
        methodStatic();
    }
    public static void methodStatic(){

    }

0 invokestatic #8 <com/atguigu/java/MethodInvokeReturnTest.methodStatic>
3 return

    //方法调用指令:invokeinterface
    public void invoke3(){
        Thread t1 = new Thread();
        ((Runnable)t1).run();

        Comparable<Integer> com = null;
        com.compareTo(123);
    }

 0 new #4 <java/lang/Thread>
 3 dup
 4 invokespecial #5 <java/lang/Thread.<init>>
 7 astore_1
 8 aload_1
 9 invokeinterface #9 <java/lang/Runnable.run> count 1
14 aconst_null
15 astore_2
16 aload_2
17 bipush 123
19 invokestatic #10 <java/lang/Integer.valueOf>
22 invokeinterface #11 <java/lang/Comparable.compareTo> count 2
27 pop
28 return

方法返回指令

方法调用结束前，需要进行返回。方法返回指令是根据返回值的类型区分的。

• 包括ireturn (当返回值是boolean， byte，char，short和int 类型时使用)、lreturn，freturn，dreturn和areturn

• 另外还有一条return指令供声明为void的方法、实例初始化方法以及类和接口的类初始化方法使用。

• 

举例:

• 通过ireturn指令，将当前函数操作数栈的顶层元素弹出，并将这个元素压入调用者函数的操作数栈中(因为调用者非常关心函数的返回值)，所有在当前函数操作数栈中的其他元素都会被丢弃。

• 如果当前返回的是synchronized方法，那么还会执行一个隐含的monitorexit指令，退出临界区。

• 最后，会丢弃当前方法的整个帧，恢复调用者的帧，并将控制权转交给调用者。 ```java //方法的返回指令 public int returnInt(){

    int i = 500;
    return i;
  

  }

  public double returnDouble(){

    return 0.0;
  

  }

  public String returnString(){

    return "hello,world";
  

  }

  public int[] returnArr(){

    return null;
  

  } public float returnFloat(){

    int i = 10;
    return i;
  

  }

  public byte returnByte(){

    return 0;
  

  }

  public void methodReturn(){

    int i = returnByte();
  

  }

---

<a name="Jh9MG"></a>
## 操作数栈管理指令
操作数栈管理指令：如同操作一个普通数据结构中的堆栈那样，JVM提供的操作数栈管理指令，可以用于直接操作操作数栈的指令。

这类指令包括如下内容：

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

<br />

- 复制栈项一个或两个数值并将复制值或双份的复制值重新压入栈顶：dup, dup2, dup_x1，dup2_x1, dup_x2, dup2_x2；

<br />

- 将栈最顶端的两个Slot数值位置交换: swap。 Java 虚拟机没有提供交换两个64位数据类型(long、double) 数值的指令。

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

<br />

- 这些指令属于通用型，对栈的压入或者弹出无需指明数据类型。



**说明：**

- 不带_x的指令是复制栈顶数据并压入栈顶。包括两个指令，dup和dup2。 dup的系数代表要复制的Slot个数。
   - dup开头的指令用于复制1个Slot的数据。例如1个int或1个reference类型数据
   - dup2开头的指令用于复制2个Slot的数据。例如1个long，或2个int， 或1个int+1个。float类型数据

<br />

- 带_x的指令是复制栈顶数据并插入栈顶以下的某个位置。 共有4个指令,dup_x1, dup2_x1，dup_x2, dup2_x2。 对于带_x的复制插入指令，只要将指令的dup和x的系数相加，结果即为需要插入的位置。因此
   - dup_x1插入位置: 1+1=2， 即栈顶2个Slot下面
   - dup_x2插入位置: 1+2=3，即栈项3个Slot下面
   - dup2_x1插入位置: 2+1=3， 即栈顶3个Slot 下面
   - dup2_x2插入位置: 2+2=4， 即栈顶4个Slot下面

<br />

- pop:将栈顶的1个Slot数值出栈。例如1个short类型数值

<br />

- pop2: 将栈顶的2个Slot数值 出栈。例如1个double类型数值， 或者2个int类型 数值



**举例：**
```java
public class StackOperateTest {

    public void print(){
        Object obj = new Object();
        String info = obj.toString();
        obj.toString();
    }
    //类似的
    public void foo(){
        bar();
    }
    public long bar(){
        return 0;
    }


}

 0 new #3 <java/lang/Object>
 3 dup
 4 invokespecial #1 <java/lang/Object.<init>>
 7 astore_1
 8 aload_1
 9 invokevirtual #4 <java/lang/Object.toString>
12 astore_2
13 aload_1
14 invokevirtual #4 <java/lang/Object.toString>
17 pop
18 return

  public long nextIndex() {
        return index++;
    }

    private long index = 0;

0 aload_0      //操作数栈中加载this对象的地址
 1 dup            //复制一份地址到栈顶
 2 getfield #2     //获取index的值0，放入栈顶，消耗一个this
 5 dup2_x1     //复制index一份放到栈顶第三个位置(slot)的下面
 6 lconst_1     //加载1
 7 ladd           //弹出栈顶两个值，相加的结果压入栈顶
 8 putfield #2    //弹出栈顶的两个值，做赋值操作
11 lreturn      //注意：index确实变成1了，但是返回值是0

putfield操作将栈顶的1和this对象弹出并做赋值操作，紧接着弹出返回栈顶元素0

控制转移指令

程序流程离不开条件控制，为了支持条件跳转,虚拟机提供了大量字节码指令，大体上可以分为
比较指令、条件跳转指令、比较条件跳转指令、多条件分支跳转指令、无条件跳转指令等。

条件跳转指令

• 条件跳转指令通常和比较指令结合使用。在条件跳转指令执行前，一般可以先用比较指令进行栈顶元素的准备，然后进行条件跳转。

• 条件跳转指令有: ifeq， iflt, ifle，ifne，ifgt，ifge，ifnull, ifnonnull。这些指令都接收两个字节的操作数，用于计算跳转的位置(16位符号整数作为当前位置的offset)。

• 它们的统一含义为：弹出栈顶元素，测试它是否满足某一条件，如果满足条件，则跳转到给定位置。

具体说明

注意：

• 与前面运算规则一致:
  • 对于boolean、byte、char、short类型的条件分支比较操作，都是使用int类型的比较指令完成
  • 对于long、float、double类型的条件分支比较操作，则会先执行相应类型的比较运算指令，运算指令会返回一个整型值到操作数栈中，随后再执行int类型的条件分支比较操作来完成整个分支跳转

• 由于各类型的比较最终都会转为int类型的比较操作，所以Java虚拟机提供的int类型的条件分支指令是最为丰富和强大的。

    //1.条件跳转指令
    public void compare1(){
        int a = 0;
        if(a != 0){
            a = 10;
        }else{
            a = 20;
        }
    }
  

  
  注意：字节码第三行使用的是ifeq，源码是!=，意思是先判断需要跳转的情况，如果不需要，直接继续向下执行即可。

  public class IfSwitchGotoTest {
    //1.条件跳转指令
    public void compare1(){
        int a = 0;
        if(a != 0){
            a = 10;
        }else{
            a = 20;
        }
    }
    public boolean compareNull(String str){
        if(str == null){
            return true;
        }else{
            return false;
        }
    }
    //结合比较指令
    public void compare2() {
        float f1 = 9;
        float f2 = 10;
        System.out.println(f1 < f2);//true
    }
    public void compare3() {
        int i1 = 10;
        long l1 = 20;
        System.out.println(i1 > l1);
    }
  
    public int compare4(double d) {
        if (d > 50.0) {
            return 1;
        } else {
            return -1;
        }
    }
  }
  

比较条件跳转指令

• 比较条件跳转指令类似于比较指令和条件跳转指令的结合体，它将比较和跳转两个步骤合二为一。

• 这类指令有：ificmpeq、 if_icmpne、 if_icmplt、if_icmpgt、 if_icmple、 if_icmpge、 if_acmpeq和if acmpne。其中指令助记符加上“if”后，以字符“i”开头的指令针对int型整数操作(也包括short和byte类型)，以字符“a”开头的指令表示对象引用的比较。

具体说明：

• 这些指令都接收两个字节的操作数作为参数，用于计算跳转的位置。同时在执行指令时，栈顶需要准备两个元素进行比较。指令执行完成后，栈顶的这两个元素被清空，且没有任何数据入栈。如果预设条件成立，则执行跳转，否则，继续执行下一条语句。

    //2.比较条件跳转指令
    public void ifCompare1(){
        int i = 10;
        int j = 20;
        System.out.println(i > j);
    }
    public void ifCompare2() {
        short s1 = 9;
        byte b1 = 10;
        System.out.println(s1 > b1);
    }
  
    public void ifCompare3() {
        Object obj1 = new Object();
        Object obj2 = new Object();
        System.out.println(obj1 == obj2);//false
        System.out.println(obj1 != obj2);//true
    }
  

  

  多条件分支跳转指令

• 多条件分支跳转指令是专为switch-case语句设计的，主要有tableswitch和lookupswitch。

• 从助记符上看，两者都是switch语句的实现，它们的区别:
  • tableswitch要求多个条件分支值是连续的，它内部只存放起始值和终止值，以及若干个跳转偏移量，通过给定的操作数index,可以立即定位到跳转偏移量位置，因此效率比较高。
  • 指令lookupswitch内部存放着各个离散的case-offset对，每次执行都要搜索全部的case-offset对，找到匹配的case值，并根据对应的offset计算跳转地址，因此效率较低。

• 指令tableswitch的示意图如下图所示。由于tableswitch的case值是连续的，因此只需要记录最低值和最高值，以及每项对应的offset偏移量，根据给定的index值通过简单的计算即可直接定位到offset。

• 指令lookupswitch处理的是离散的case值，但是出于效率考虑，将case-offset对按照case值大小排序，给定index时，需要 查找与index相等的case,获得其offset ,如果找不到则跳转到default。指令lookupswitch如下图所示。

    //3.多条件分支跳转
    public void swtich1(int select){
        int num;
        switch(select){
            case 1:
                num = 10;
                break;
            case 2:
                num = 20;
                //break;
            case 3:
                num = 30;
                break;
            default:
                num = 40;
        }

    }
    public void swtich2(int select){
        int num;
        switch(select){
            case 100:
                num = 10;
                break;
            case 500:
                num = 20;
                break;
            case 200:
                num = 30;
                break;
            default:
                num = 40;
        }
    }
    //jdk7新特性：引入String类型
    public void swtich3(String season){
        switch(season){
            case "SPRING":break;
            case "SUMMER":break;
            case "AUTUMN":break;
            case "WINTER":break;
        }
    }

无条件跳转指令

• 目前主要的无条件跳转指令为goto。指令goto接收两个字节的操作数，共同组成一个带符号的整数，用于指定指令的偏移量，指令执行的目的就是跳转到偏移量给定的位置处。

• 如果指令偏移量太大，超过双字节的带符号整数的范围，则可以使用指令goto_w, 它和goto有相同的作用，但是它接收4个字节的操作数，可以表示更大的地址范围。

• 指令jsr、jsr_w、ret 虽然也是无条件跳转的，但主要用于try-finally语句，且已经被虚拟机逐渐废弃，故不在这里介绍这两个指令。

    //4.无条件跳转指令
    public void whileInt() {
        int i = 0;
        while (i < 100) {
            String s = "atguigu.com";
            i++;
        }
    }

    public void whileDouble() {
        double d = 0.0;
        while(d < 100.1) {
            String s = "atguigu.com";
            d++;
        }
    }

    public void printFor() {
        short i;
        for (i = 0; i < 100; i++) {
            String s = "atguigu.com";
        }

    }

异常处理指令

抛出异常指令

athrow指令

• 在Java程序中显示抛出异常的操作(throw语句)都是由athrow指令来实现。（a引用类型）

• 除了使用throw语句显示抛出异常情况之外，JVM规范还规定了许多运行时异常会在其他Java虚拟机指令检测到异常状况时自动抛出（字节码文件中看不到athrow指令）。例如，在之前介绍的整数运算时，当除数为零时，虚拟机会在idiv或 idiv指令中抛出ArithmeticException异常。

注意

• 正常情况下，操作数栈的压入弹出都是一条条指令完成的。唯一的例外情况是在抛异常时，Java 虚拟机会清除操作数栈上的所有内容，而后将异常实例压入调用者操作数栈上。

异常及异常的处理：

• 过程一：异常对象的生成过程—> throw (手动/自动) —> 指令: athrow

• 过程二：异常的处理:抓抛模型。try-catch- finally —>使用异常表

    public void throwZero(int i){
        if(i == 0){
            throw new RuntimeException("参数值为0");
        }
    }
  

  

  处理异常与异常表

• 处理异常：

  • 在Java虚拟机中，处理异常(catch语句)不是由字节码指令来实现的(早期使用jsr、ret指令) ，而是采用异常表来完成的。

• 异常表

  • 如果一个方法定义了一个try-catch或者try-finally的异常处理，就会创建-一个异常表。它包含了每个异常处理或者finally块的信息。异常表保存了每个异常处理信息。比如：
    • 起始位置
    • 结束位置
    • 程序计数器记录的代码处理的偏移地址
    • 被捕获的异常类在常量池中的索引

• 当一个异常被抛出时，JVM会在当前的方法里寻找一个匹配的处理，如果没有找到，这个方法会强制结束并弹出当前栈帧，并且异常会重新抛给上层调用的方法(在调用方法栈帧)。如果在所有栈帧弹出前仍然没有找到合适的异常处理，这个线程将终止。如果这个异常在最后一个非守护线程里抛出，将会导致JVM自已终止，比如这个线程是个main线程。

• 在这种情况下，如果方法结束后没有抛出异常，仍然执行finally块， 在return前， 它直接跳到finally块来完成目标

   public void tryCatch(){
       try{
           File file = new File("d:/hello.txt");
           FileInputStream fis = new FileInputStream(file);
  
           String info = "hello!";
       }catch (FileNotFoundException e) {
           e.printStackTrace();
       }
       catch(RuntimeException e){
           e.printStackTrace();
       }
   }
  

  

//思考：如下方法返回结果为多少？
public static String func() {
    String str = "hello";
    try{
        return str;
    }finally{
        str = "atguigu";
    }
}
//返回结果：hello

同步控制指令

组成

• java虚拟机支持两种同步结构：方法级的同步和方法内部一段指令序列的同步，这两种同步都是使用monitor来支持的。

方法级的同步

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

• 当调用方法时，调用指令将会检查方法的ACC_SYNCHRONIZED访问标志是否设置。

  • 如果设置了，执行线程将先持有同步锁，然后执行方法。最后在方法完成(无论是正常完成还是非正常完成)时释放同步锁。
  • 在方法执行期间，执行线程持有了同步锁，其他任何线程都无法再获得同一个锁。
  • 如果一个同步方法执行期间抛出了异常，并且在方法内部无法处理此异常，那这个同步方法所持有的锁将在异常抛到同步方法之外时自动释放。

举例：

    private int i = 0;
    public synchronized void add(){
        i++;
    }

 0 aload_0
 1 dup
 2 getfield #2 
 5 iconst_1
 6 iadd
 7 putfield #2 
 10 return

说明：

• 这段代码和普通的无同步操作的代码没有什么不同，没有使用monitorenter和monitorexit进行同步区控制。这是因为，对于同步方法而言，当虚拟机通过方法的访问标示符判断是一个同步方法时，会自动在方法调用前进行加锁，当同步方法执行完毕后，不管方法是正常结束还是有异常抛出，均会由虚拟机释放这个锁。因此，对于同步方法而言，monitorenter和monitorexit指令是隐式存在的，并未直接出现在字节码中。

方法内指定指令序列的同步

• 同步一段指令集序列：通常是由Java中的synchronized语句块来表示的。jvm的指令集有monitorenter和monitorexit两条指令来支持synchronized关键字的语义

• 当一个线程进入同步代码块时，它使用monitorenter指令请求进入。如果当前对象的监视器计数器为0，则它会被准许进入，若为1，则判断持有当前监视器的线程是否为自己，如果是，则进入，否则进行等待，直到对象的监视器计数器为0，才会被允许进入同步块

• 当线程退出同步块时，需要使用monitorexit声明退出。在Java虚拟机中，任何对象都有一个监视器与之相关联，用来判断对象是否被锁定，当监视器被持有时，对象处于锁定状态

• 指令monitorenter和monitorexit在执行时，都需要在操作数栈顶压入对象，之后monitorenter和monitorexit的锁定和释放都是针对这个对象的监视器进行的

• 下图展示了监视器如何保护临界区代码不同时被多个线程访问，只有当线程4离开临界区后，线程1、2、3才有可能进入。

• 举例：

    private Object obj = new Object();
    public void subtract(){
  
        synchronized (obj){
            i--;
        }
    }
  

  
  异常表：

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

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