java 异常－性能及实现机制分析

网络上好多文章都分析了java语言try－catch－finally语句（下文中称try语句）的使用及返回值问题，但是对try语句的性能及其实现机制较少提及，本文依据try语句生成的字节码文件，分析try语句的性能及实现机制。

try语句的性能

问题由来

工作期间，曾被人问到过下面这样的一个问题，请看下面测试代码

public class Test {    public static void main ( String[] args ) {        outerTry( args );        innerTry( args );           }    private static void outerTry ( String[] args ) {        try {            for ( String arg : args ) {                tryMethod();            }        }catch ( Exception e ){            catchMethod();        }    }    private static void innerTry ( String[] args ) {        for ( String arg : args ) {            try{                tryMethod();            }catch ( Exception e ){                catchMethod();            }        }    }    private static void tryMethod () { }    private static void catchMethod () { }}

上述代码中，如果在tryMethod()方法中没有抛出异常，那么innerTry ( String[] args )与outerTry ( String[] args )在性能上有多大差别?

分析字节码文件

对代码进行反编译，通过字节码文件分析差异，执行下面语句

javap -c -p Test.class

下面仅保留了innerTry()与outerTry()方法的字节码

  private static void outerTry(java.lang.String[]);    Code:       0: aload_0       1: astore_1       2: aload_1       3: arraylength       4: istore_2       5: iconst_0       6: istore_3       7: iload_3       8: iload_2       9: if_icmpge     26      12: aload_1      13: iload_3      14: aaload      15: astore        4      17: invokestatic  #4                  // Method tryMethod:()V      20: iinc          3, 1      23: goto          7      26: goto          33      29: astore_1      30: invokestatic  #6                  // Method catchMethod:()V      33: return    Exception table:       from    to  target type           0    26    29   Class java/lang/Exception private static void innerTry(java.lang.String[]);    Code:       0: aload_0       1: astore_1       2: aload_1       3: arraylength       4: istore_2       5: iconst_0       6: istore_3       7: iload_3       8: iload_2       9: if_icmpge     34      12: aload_1      13: iload_3      14: aaload      15: astore        4      17: invokestatic  #4                  // Method tryMethod:()V      20: goto          28      23: astore        5      25: invokestatic  #6                  // Method catchMethod:()V      28: iinc          3, 1      31: goto          7      34: return    Exception table:       from    to  target type          17    20    23   Class java/lang/Exception

为下面叙述方便，将code：下面的0，1 等标号，称为第0行，第1行。实际上表示的是JVM指令所在的内存位置，不同的指令，指令长度可能不一致，因此可以发现值是不连续的。
先看两个方法的指令码，发现第0-17行都是一致的，后面开始有差异。
innerTry的第17行执行后，执行了goto语句跳转到第28行指令（第20行语句），第28行是iinc指令，与outerTry中的20行一致，interTry中第28行结束后，第31行执行了goto语句，与outerTry中的23行是一致的，全部跳转到了第7行。因此两者的差异仅在于innerTry比outerTry多执行了一条1个字节长度的goto指令，因此两者的性能可以认为是没有差异的。

小结

通过上面分析可以看到，两者差别仅在于一条goto语句，所以可以认为两者的性能是没有差异的

try-catch语句的实现机理

新的问题来了，我们的代码及反编译代码中都有catch语句，那么catch语句是如何被找到的呢？
java对try语句的执行是通过异常表进行的。
看innerTry与outerTry反编译下面都有如下所示的反编译代码

    Exception table:       from    to  target type          17    20    23   Class java/lang/Exception

这个就是异常表，上面的异常表来自于innerTry方法。
异常表有四部分组成，from，to，target，type。from表示从哪个字节指令开始，to表示到哪个字节指令结束（不包含），target表示如果发生异常了，下一步应该执行哪个指令，type表示匹配的异常，如果这个异常没有匹配上，是不会执行target地方的指令的。因此，上面的异常表表明，从第17行指令开始，到第20行指令(不包含）结束（正好是tryMethod），如果发生Exception类型的异常，就去执行第23行的代码，而第23行的代码是astore（将异常对象压入栈），第25行代码是执行catchMethod方法。
代码进行编译时，编译器根据try语句生成异常表。当发生异常时，查询异常表是根据顺序进行的，因此，大家就理解，为什么如果有多个异常的时候，需要把先想要匹配的放在前面。如果在这个异常表中指不到相应的处理代码。

finally语句块的实现机制及其对返回值和异常的影响

我们来看下面的代码

public static void main ( String[] args ) {        try {            tryMethod();        }catch ( Exception e ){            catchMethod();        }finally {            finallyMethod();        }    }    private static void finallyMethod () { }    private static void tryMethod () { }    private static void catchMethod () { }

通过反编译，查看字节码文件

public static void main(java.lang.String[]);    Code:       0: invokestatic  #2                  // Method tryMethod:()V       3: invokestatic  #3                  // Method finallyMethod:()V       6: goto          25       9: astore_1       10: invokestatic  #5                  // Method catchMethod:()V       13: invokestatic  #3                  // Method finallyMethod:()V      16: goto          25       19: astore_2       20: invokestatic  #3                  // Method finallyMethod:()V      23: aload_2                        // 从本地变量存入堆栈（抛出的异常，与第19行对应）      24: athrow                        // 将异常抛出      25: return    Exception table:       from    to  target type           0     3     9   Class java/lang/Exception           0     3    19   any           9    13    19   any}

先简单介绍几个字节指令，astore_1，即将引用对象从堆栈存入本地变量 1 中，aload_2是将第2个本地变量压入堆栈中，athrow方法是抛出异常的指令 ，即对应于java语言中的throw。
分析上面的的字节码内容，发现finallyMethod（）方法在字节码中出现了三次，分别在tryMethod后，catchMethod方法后及原来的finally语句块中。即finally语句是通过插入到try与catch语句块中而被执行的（finally语句被称为subroutine）。

现在分析异常表，共三行
1. 如果第0行到第3行（即tryMethod方法）发生了异常，并且异常是Exception类型，则执行第9行（存储异常，执行catchMethod方法）指令。
2. 如果第0行到第3行（即tryMethod方法）发生了异常，异常类型是any，说明是任何类型，因为上面第一条已经匹配了Exception，所以此处是非Exception异常，则执行第19行指令（存储异常，执行finally语句异常）
3. 如是要第9行到第13行（即catchMethod方法）发生了任意类型的异常时，执行第19行指令（即存储异常，执行finally异常）

因此，通过上面的分析，与我们的正常的认知是一样的，即
1. 当 try语句块不发生异常时，直接执行第3行（即finally 语句块）
2. 当try 语句块发生异常时，并且类型是Exception类型时，执行catch 语句块
3. 当try 语句块发生异常时，但是类型没有被catch语句匹配时，直接执行finally语句块的方法
4. 如果发生异常，被catch语句匹配后，如果在catch 语句块中抛出异常，则执行finally语句块的内容
5. 如果try语句发生的异常没有被catch的类型没有匹配到，或者catch语句中发生了异常，则都会执行第19行，即存储异常信息，调用finally语句块的内容，执行完后，通过调用athrow指令，将刚才的异常抛出。

finally语句块对返回值的影响

上面的代码中try 语句块与catch 语句块没有返回值，最后通过第25行的指令return返回，现在在try与catch语句块中增加返回值

public class Test {    public static void main ( String[] args ) {        test();    }    private static int test () {        try {            tryMethod();            return 0;        }catch ( Exception e ){            catchMethod();            return 1;        }finally {            finallyMethod();            return 2;      // 虽然可以正常编译通过，但是编译器可能会给警告，即不要在finally块中增加return语句        }           }    private static void finallyMethod () { }    private static void tryMethod () { }    private static void catchMethod () { }}

将代码进行反编译，查看test方法的字节码文件

 private static int test();    Code:       0: invokestatic  #3                  // Method tryMethod:()V       3: iconst_0       4: istore_0       5: invokestatic  #4                  // Method finallyMethod:()V       8: iconst_2       9: ireturn      10: astore_0      11: invokestatic  #6                  // Method catchMethod:()V      14: iconst_1      15: istore_1      16: invokestatic  #4                  // Method finallyMethod:()V      19: iconst_2      20: ireturn      21: astore_2      22: invokestatic  #4                  // Method finallyMethod:()V      25: iconst_2      26: ireturn    Exception table:       from    to  target type           0     5    10   Class java/lang/Exception           0     5    21   any          10    16    21   any

第3，4行指令，将常量“0”存入本地变量，第8行，第9行，将常量”2”返回，第14，15行，将常量”1”存入本地变量中，第19，20行，将常量”1”返回，第21行存储try语句或者catch语句产生的异常，第25行，26行，将常量”2”返回。因此，可以发现，不管怎么样，都没有返回常量“0”或者常量“1”，都是返回的常量“2”，即执行了finally中的return语句。
去掉finally语句块中的return语句，做个对比，字节码如下

 private static int test();    Code:       0: invokestatic  #3                  // Method tryMethod:()V       3: iconst_0       4: istore_0       5: invokestatic  #4                  // Method finallyMethod:()V       8: iload_0       9: ireturn      10: astore_0      11: invokestatic  #6                  // Method catchMethod:()V      14: iconst_1      15: istore_1      16: invokestatic  #4                  // Method finallyMethod:()V      19: iload_1      20: ireturn      21: astore_2      22: invokestatic  #4                  // Method finallyMethod:()V      25: aload_2      26: athrow    Exception table:       from    to  target type           0     5    10   Class java/lang/Exception           0     5    21   any          10    16    21   any

对比上面的这两块字节码会发现，只有在第8行，第19行，第25行是不一样的，前者分别取的是finally中的返回值，而后者取的是try语句，catch语句的返回值或者抛出发生的异常值。
现在重点来看第26行，前者是ireturn，后者是athrow，即前者是不会再抛出异常的，即如果try语句中发生了没有被catch语句捕获的异常，或者在catch语句块中发生了异常，异常会被无情的吞掉。因此在finally中写return语句，是代码大忌。
因此，通过对比就可以发现，在执行try语句块或者catch语句块的return语句之前，都会将返回结果进行存储，在执行完finally语句块后，将刚才的值load出来返回。而如果在finally语句块中增加了return语句的话，返回值是finally语句中的return语句，同时还还可能吞掉异常。

结论

由此，可以得到以下几个结论：
1. 代码增加try-catch语句后，在没有发生异常情况下，不会对性能造成影响（最多相差几条指令，文中例子多了一条goto指令）；
2. 执行哪个异常语句是通过查异常表完成的，异常表的顺序是由编译器保证的；
3. finally语句是作为“subroutine”插入到try-catch代码块中执行的；
4. finally语句中增加return语句时，finally语句的返回值会覆盖try或者catch语句块的返回值，并有可能会吞掉异常，代码大忌。