try catch finally机制分析

原创狐友技术团队搜狐技术产品

本文字数：13355字

预计阅读时间：34分钟

一. 静态代码检测问题提示

最近项目代码静态检测，报出大量类似的错误提示：

相应代码的错误说明如下(会导致异常被 finally 的 return 覆盖掉，而无法被调用者正确处理)：

public static void main(String[] args) {
  try {
    doSomethingWhichThrowsException();
    System.out.println("OK"); // incorrect!!! "OK" message is printed
  } catch (RuntimeException e) {
    System.out.println("ERROR"); // incorrect!!! this message is not shown
  }
}

public static void doSomethingWhichThrowsException() {
  try {
    throw new RuntimeException();
  } finally {
    /* ... */
    return; // Noncompliant - prevents the RuntimeException from being propagated
  }
}

二. 执行原理分析

我们知道finally的代码一定会被执行，除非下面2中情况 :

如果在try或catch语句中执行了System.exit(0) or 死循环了。
在执行finally之前jvm崩溃了。

finally语句执行时，会遵守下面3个原则：

不管try中有没有出现异常，finally中代码都会执行；
当try和catch中有return时，finally中代码仍然会执行；
finally代码块是在return后面的表达式运算后，return操作前执行的。如下例所示，尽管 finally 中的代码改变 return 返回的那个变量，但函数最终的返回值没有改变，因为 return 返回值是在 finally 代码执行前就已经确定了。

public class Test {
    public static void main(String[] args) {
        System.out.println(test());
    }
    
    public static int test() {
        int i = 0;
        try {
            i = 1;
            return i;
        } finally {
            i = 2;
            System.out.println("finally code.");
        }
    }
}

//输出结果
finally code.
1
//此处中finally中对i赋值2。 但是test的返回值仍然是1,
//也就是在finally中对i赋值并未改变i的返回值.

我们可以通过 javac，javap 查看到对应代码的字节码 (或者在AS中安装 Bytecode viewer jclasslib 插件查看字节码)，如下：

public class Test {
    public Test();
      Code:
        0: aload_0
        1: invokespecial #1 // Method java/lang/Object."<init>":()V
        4: return
    
    public static void main(java.lang.String[]);
      Code:
        0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
        3: invokestatic #3 // Method test:()I
        6: invokevirtual #4 // Method java/io/PrintStream.println:(I)V
        9: return
        
    public static int test();
      Code:
        0: iconst_0
        1: istore_0
        2: iconst_1
        3: istore_0
        4: iload_0
        5: istore_1
        6: iconst_2
        7: istore_0
        8: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
        11: ldc #5 // String finally code.
        13: invokevirtual #6 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        16: iload_1
        17: ireturn
        18: astore_2
        19: iconst_2
        20: istore_0
        21: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
        24: ldc #5 // String finally code.
        26: invokevirtual #6 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        29: aload_2
        30: athrow
      Exception table:
        from to target type
        2 6 18 any
}

由上可见，从字节码中，我们可以看到更多代码的运行细节。

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

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

具体操作码的意义可以查看：《深入理解Java虚拟机》周志明版本的附录B：虚拟机字节码指令表。

那么，下面我们将从字节码的分析过程来进行异常执行的原理分析：

1. JVM如何处理catch异常呢？

先看示例代码：

public class Test {
    public static void main(String[] args) {
      // System.out.println(test());
    }
    
    public static int test() {
        int i = 0;
        try {
            i = 1;
            return i;
        } catch (NullPointerException ex) {
            handleException(ex);
        } catch (IndexOutOfBoundsException ex) {
            handleException(ex);
        } catch (NumberFormatException ex) {
            handleException(ex);
        }
        return 10;
    }
    
    public static void handleException(Exception ex) {
    }
}

对应的字节码如下，我们主要分析test方法:

public class Test {
    public Test();
      Code:
        0: aload_0
        1: invokespecial #1 // Method java/lang/Object."<init>":()V
        4: return
    
    public static void main(java.lang.String[]);
      Code:
        0: return
    
    public static int test();
      Code:
        0: iconst_0 // 将常量0，加载到操作数栈的栈顶
        1: istore_0 // 将操作数栈顶数值，存储到局部变量表0位(slot0=0)
        2: iconst_1 // 将常量1，加载到操作数栈的栈顶
        3: istore_0 // 将操作数栈顶数值，存储到局部变量表0位(slot0=1)
        4: iload_0 // 将局部变量表0位，加载到操作数栈顶(slot0=1)
        5: ireturn // 返回 操作数栈顶元素(slot0=1)
        6: astore_1 // 将操作数栈顶Exception，存储到局部变量表1位(slot1=NullPointerException)
        7: aload_1 // 将局部变量表1位，加载到操作数栈顶slot1=NullPointerException)
        8: invokestatic #3 // 调用Method handleException:(Ljava/lang/Exception;)V
        11: goto 27 // 无条件跳转，执行指令27
        14: astore_1
        15: aload_1
        16: invokestatic #3 // 调用Method handleException:(Ljava/lang/Exception;)V
        19: goto 27
        22: astore_1
        23: aload_1
        24: invokestatic #3 // 调用Method handleException:(Ljava/lang/Exception;)V
        27: bipush 10 // 将一个常量10，加载到操作数栈顶
        29: ireturn // 返回操作数栈顶数值
      Exception table: // 异常处理表
        from to target type
        2 5 6 Class java/lang/NullPointerException
        2 5 14 Class java/lang/IndexOutOfBoundsException
        2 5 22 Class java/lang/NumberFormatException
    
    public static void handleException(java.lang.Exception);
      Code:
        0: return
}

字节码和方法对应关系如图：

在编译后字节码中，test 方法附带一个异常表（Exception table），异常表里的每一行表示一个异常处理器，由 from 指针、to 指针、target 指针、所捕获的异常类型 type 组成。

这些指针的值是字节码索引，用于定位字节码其含义是在[from, to)字节码范围内，抛出了异常类型为 type 的异常，就会跳转到 target 表示的字节码处。

当程序出现异常时，Java 虚拟机会从上至下遍历异常表中所有的条目。当触发异常的字节码索引值在某个异常条目的[from, to)范围内，则会判断抛出的异常与该条目想捕获的异常是否匹配。

如果匹配，Java 虚拟机会将控制流跳转到 target 指向的字节码；如果不匹配则继续遍历异常表
如果遍历完所有的异常表，还未匹配到异常处理器，那么该异常将抛出到调用方（caller）中重复上述的操作。最坏的情况下虚拟机需要遍历该线程 Java 栈上所有方法的异常表。如果在方法栈中所有的调用方中，都未找到可匹配的异常表，JVM会清空当前方法栈。

2. JVM如何保证finally 关键字始终执行呢？

先上示例代码：

public class Test {
    public static void main(String[] args) {
        System.out.println(test());
    }
    
    public static int test() {
        int i = 0;
        try {
        i = 1;
        return i;
        } catch (Exception ex) {
        handleException(ex);
        } finally {
        handleFinally();
        }
        return 10;
    }
    
    public static void handleException(Exception ex) {
    }
    
    public static void handleFinally() {
    }
}

对应的字节码如下，我们主要分析test方法:

public class Test {
    public Test();
      Code:
        0: aload_0
        1: invokespecial #1 // Method java/lang/Object."<init>":()V
        4: return
        
    public static void main(java.lang.String[]);
      Code:
        0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
        3: invokestatic #3 // Method test:()I
        6: invokevirtual #4 // Method java/io/PrintStream.println:(I)V
        9: return
        
    public static int test();
      Code:
        0: iconst_0 // 将常量0，加载到操作数栈的栈顶
        1: istore_0 // 将操作数栈顶数值，存储到局部变量表0位(slot0=0)
        2: iconst_1 // 将常量1，加载到操作数栈的栈顶
        3: istore_0 // 将操作数栈顶数值，存储到局部变量表0位(slot0=1)
        4: iload_0 // 将局部变量表0位，加载到操作数栈顶(slot0=1)
        5: istore_1 // 将操作数栈顶数值，存储到局部变量表1位(slot1=1)
        6: invokestatic #5 // 调用Method handleFinally:()V
        9: iload_1 // 将局部变量表1位，加载到操作数栈顶(slot1=1)
        10: ireturn // 返回 操作数栈顶元素(slot1=1)
        11: astore_1 // 将操作数栈顶Exception，存储到局部变量表1位(slot1=Exception)
        12: aload_1 // 将局部变量表1位，加载到操作数栈顶slot1=Exception)
        13: invokestatic #7 // 调用Method handleException:(Ljava/lang/Exception;)V
        16: invokestatic #5 // 调用Method handleFinally:()V
        19: goto 28 // 无条件跳转，执行指令28
        22: astore_2 // 将操作数栈顶Throwable，存储到局部变量表1位(slot2=Throwable)
        23: invokestatic #5 // 调用Method handleFinally:()V
        26: aload_2 // 将局部变量表2位，加载到操作数栈顶(slot2=Throwable)
        27: athrow // 抛出未捕获的异常(slot2=Throwable)
        28: bipush 10 // 将一个常量10，加载到操作数栈顶
        30: ireturn // 返回操作数栈顶数值
      Exception table:
        from to target type
        2 6 11 Class java/lang/Exception
        2 6 22 any
        11 16 22 any
        
    public static void handleException(java.lang.Exception);
      Code:
        0: return
        
    public static void handleFinally();
      Code:
        0: return
}

字节码和方法对应关系如图：

从对比图中可以清楚的看到，字节码中包含了三次 finally 函数的调用，一次是在 try return前，一次是在 catch 调用 return 前，还有一处是在异常 throw 前。

而对比上面的例子的字节码，我们可以发现比我们编写的代码多了桔色区域的 catch 代码块，和异常表any类型的异常映射，这是为什么呢？

这主要是为了确保 finally 块的代码被执行：在未捕获异常的情况下，确保能调用到finally块，然后再将未处理异常抛出去。

Java 采用方式是复制 finally 代码块的内容，分别放在 try，catch 代码块所有正常 return 和异常 throw 之前，所以finally 代码块始终会执行。

3. JVM如何处理返回值的呢？

有两个并不常用的场景，但是会让很多同学产生疑惑的场景，就是返回值处理情况。

finally 中修改返回值场景下列代码运行结果是1，还是3呢？运行代码可知，运行结果为1。

public class Test {
    public static void main(String[] args) {
        System.out.println(test());
    }
    
    public static int test() {
        int i = 0;
        try {
            i = 1;
            return i;
        } catch (Exception ex) {
            i = 2;
            return i;
        } finally {
            i = 3;
        }
    }
}

对应的字节码如下，我们主要分析test方法:

public class Test {
    public Test();
      Code:
        0: aload_0
        1: invokespecial #1 // Method java/lang/Object."<init>":()V
        4: return
        
    public static void main(java.lang.String[]);
      Code:
        0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
        3: invokestatic #3 // Method test:()I
        6: invokevirtual #4 // Method java/io/PrintStream.println:(I)V
        9: return
        
    public static int test();
      Code:
        0: iconst_0 // 将常量0，加载到操作数栈的栈顶
        1: istore_0 // 将操作数栈顶数值，存储到局部变量表0位(slot0=0)
        2: iconst_1 // 将常量1，加载到操作数栈的栈顶
        3: istore_0 // 将操作数栈顶数值，存储到局部变量表0位(slot0=1)
        4: iload_0 // 将局部变量表0位，加载到操作数栈顶(slot0=1)
        5: istore_1 // 将操作数栈顶数值，存储到局部变量表1位(slot1=1) ---没有finally时，没有这一步！
        6: iconst_3 // 将常量3，加载到操作数栈的栈顶
        7: istore_0 // 将操作数栈顶数值，存储到局部变量表0位(slot0=3)
        8: iload_1 // 将局部变量表1位，加载到操作数栈顶(slot1=1)
        9: ireturn // 返回 操作数栈顶元素(slot1=1) ---注意返回的是slot1加载到栈顶的数值1！
        10: astore_1 // 将操作数栈顶Exception，存储到局部变量表1位(slot1=Exception)
        11: iconst_2 // 将常量2，加载到操作数栈的栈顶
        12: istore_0 // 将操作数栈顶数值，存储到局部变量表0位(slot0=2)
        13: iload_0 // 将局部变量表0位，加载到操作数栈顶(slot0=2)
        14: istore_2 // 将操作数栈顶数值，存储到局部变量表2位(slot2=2)
        15: iconst_3 // 将常量3，加载到操作数栈的栈顶
        16: istore_0 // 将操作数栈顶数值，存储到局部变量表0位(slot0=3)
        17: iload_2 // 将局部变量表2位，加载到操作数栈顶(slot2=2)
        18: ireturn // 返回 操作数栈顶元素(slot2=2) ---注意返回的是slot2加载到栈顶的数值2！
        19: astore_3 // 将操作数栈顶Throwable，存储到局部变量表1位(slot3=Throwable)
        20: iconst_3 // 将常量3，加载到操作数栈的栈顶
        21: istore_0 // 将操作数栈顶数值，存储到局部变量表0位(slot0=3)
        22: aload_3 // 将局部变量表3位，加载到操作数栈顶(slot3=Throwable)
        23: athrow // 抛出未捕获的异常(slot3=Throwable)
      Exception table:
        from to target type
        2 6 10 Class java/lang/Exception
        2 6 19 any
        10 15 19 any
}

字节码和方法对应关系如图：

通过字节码，我们发现，在 try 和 catch 语句的 return 块中，return 返回的变量并不是直接返回 i 值，而是在执行 finally 块之前把i值存储在临时区域，当执行 return 时直接返回的临时区域中的值。

比如，在 try 中，实际返回的是 slot1 中存储的1，而非 slot0 中的3。在 catch 中，实际返回的是 slot2 中的2，而非 slot0 中的3.

所以，即使在 finally 语句中把变量 i 的值修改了，也不会影响函数的返回值。

finally 中有return 的场景当 finally 中有 return 语句时，结果和上面就完全不同了，finally 中的 return 语句会重写 try和 catch 代码块中的返回值。

上面的例子稍作修改：在finally 语句中增加一行返回值操作，运行代码，结果就变成了3。

public class Test {
    public static void main(String[] args) {
        System.out.println(test());
    }
    
    public static int test() {
        int i = 0;
        try {
            i = 1;
            return i;
        } catch (Exception ex) {
            i = 2;
            return i;
        } finally {
            i = 3;
            return i;
        }
    }
}

对应的字节码如下，我们主要分析test方法：

public class Test {
    public Test();
      Code:
        0: aload_0
        1: invokespecial #1 // Method java/lang/Object."<init>":()V
        4: return
    
    public static void main(java.lang.String[]);
      Code:
        0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
        3: invokestatic #3 // Method test:()I
        6: invokevirtual #4 // Method java/io/PrintStream.println:(I)V
        9: return
    
    public static int test();
      Code:
        0: iconst_0
        1: istore_0
        2: iconst_1
        3: istore_0
        4: iload_0
        5: istore_1
        6: iconst_3
        7: istore_0
        8: iload_0
        9: ireturn
        10: astore_1
        11: iconst_2
        12: istore_0
        13: iload_0
        14: istore_2
        15: iconst_3
        16: istore_0
        17: iload_0
        18: ireturn
        19: astore_3
        20: iconst_3
        21: istore_0
        22: iload_0
        23: ireturn
      Exception table:
        from to target type
        2 6 10 Class java/lang/Exception
        2 6 19 any
        10 15 19 any
}

对比上面finally 改值不return的场景：

与上个章节的例子做对比。左侧是 finally 有 return 编译后的字节码，右侧是上面 finally 无return 的例子编译后的字节码。

可以看到，虽然 try 和 catch 中的 i 值也被暂存了，不过被 finally 的 return 语句改变了最后 return 的局部变量表的元素位置，导致返回的值最后变成了 finally 中修改后的i值。

并且，未捕获的异常处理代码，也被 finally 的 return 语句改变为 finally 修改后的局部变量表的元素位置，从而导致异常丢失！这就是文章开头，我们遇见错误提示的根本原因。

4. Try catch finally 执行情况总结

第一，JVM 采用异常表的方式来处理 try-catch 的跳转逻辑；
第二，finally 采用拷贝 finally 语句块的方式来实现 finally 一定会执行的语义逻辑；
第三，finally 不能修改 try 和 catch 中的返回值，但是可以通过 return 覆盖掉它们的返回值。

三. 不同场景下执行情况

有了上一部分的原理分析，我们就可以很轻松的梳理出各种情况下try，catch，finally的执行次序和返回位置(红色标识)了。

情况1：try{}catch(){}finally{} return;

无异常：try，finally，return
有异常被捕获：try，catch，finally， return
有异常未捕获：try，finally，抛出异常

情况2: try{ return; }catch(){}finally{} return;

无异常：try，finally
有异常被捕获：try，catch，finally， return
有异常未捕获：try，finally，抛出异常

情况3: try{}catch(){return;}finally{} return;

无异常：try，finally，return
有异常被捕获：try，catch，finally
有异常未捕获：try，finally，抛出异常

情况4: try{}catch(){}finally{return;} return;

无异常：try，finally
有异常被捕获：try，catch，finally
有异常未捕获：try，finally----异常没有被抛出，会丢失

情况5: try{ return; }catch(){}finally{return;}

无异常：try，finally
有异常被捕获：try，catch，finally
有异常未捕获：try，finally----异常没有被抛出，会丢失

情况6: try{}catch(){return;}finally{return;}

无异常：try，finally
有异常被捕获：try，catch，finally
有异常未捕获：try，finally----异常没有被抛出，会丢失

情况7: try{ return;}catch(){return;}finally{return;}

无异常：try，finally
有异常被捕获：try，catch，finally
有异常未捕获：try，finally----异常没有被抛出，会丢失。

情况8: try{ return;}finally{return;}

无异常：try，finally
有异常被捕获：NA
有异常未捕获：try，finally ----异常没有被抛出，会丢失。这正是是我们文章开头检测提示的问题！

四. 实践建议

Try catch finally的原理，我们就分析和梳理到这。

从代码的简洁性，可理解，好维护的角度看，不建议在catch和finnaly中做return处理；建议在catch做异常恢复处理，在finally做资源释放等处理，而返回值可以通过其它更清晰明了的方式返回。

如果确实要在catch和finnaly中做return处理，一定要确保正确使用，并加上详细的设计思路注释。

五. Refer：部分字节码命令说明

1. 加载和存储指令

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

将一个局部变量加载到操作栈：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。

2. 运算指令

运算或算术指令用于对两个操作数栈上的值进行某种特定运算，并把结果重新存入到操作栈顶。这些指令如下：

加法指令：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。

3. 类型转换指令

类型转换指令可以将两种不同的数值类型进行相互转换，这些转换操作一般用于实现用户代码中的显示类型转换操作。Java 虚拟机直接支持（即转换时无需显示的转换指令）。相对的，处理窄化类型转换（Narrowing Numeric Conversions）时，必须显式地使用转换指令来完成。这些指令如下：

4. 对象创建与访问指令

虽然类实例和数组都是对象，但 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。

5. 操作数栈管理指令

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

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

6. 控制转移指令

控制转移指令可以让 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。在 Java 虚拟机中有专门的指令集用来处理 int 和 reference 类型的条件分支比较操作，为了可以无须明显标识一个实体值是否 null，也有专门的指令用来检测 null 值。

与前面算术运算是的规则一致，对于 boolean 类型、byte 类型、char 类型和 short 类型的条件分支比较操作，都是使用 int 类型的比较指令来完成，而对于 long 类型、float 类型和 double 类型的条件分支比较操作，则会先执行相应类型的比较运算指令（dcmpg、dcmpl、fcmpg、fcmpl、lcmp），运算指令会返回一个整形值到操作数栈中，随后再执行 int 类型的条件分支比较操作来完成整个分支跳转。由于各种类型的比较最终都会转化为 int 类型的比较操作，int 类型比较是否方便完善就显得尤为重要，所以 Java 虚拟机提供的 int 类型的条件分支指令是最为丰富和强大的。

7. 方法调用和返回指令

方法调用（分派、执行过程），这些指令如下：

invokevirtual 指令用于调用对象的实例方法，根据对象的实际类型进行分派（虚方法分派），这也是 Java 语言中最常见的方法分派方式。
invokeinterface 指令用于调用接口方法，它会在运行时搜索一下实现了这个接口方法的对象，找出适合的方法进行调用。
invokespecial 指令用于调用一些需要特殊处理的实例方法，包括实例初始化方法、私有方法和父类方法。
invokestatic 指令用于调用类方法（static 方法）。
invokedynamic 指令用于在运行时动态解析出调用点限定符所引用的方法，并执行该方法，前面 4 条调用指令的分派逻辑都固化在 Java 虚拟机内部，而 invokedynamic 指令的分派逻辑是由用户所设定的引导方法决定的。
方法返回指令是根据返回值的类型区分的，包括 ireturn（当返回值是 boolean、byte、char、short 和 int 类型时使用）、lreturn、freturn、dreturn 和 areturn。