网络上好多文章都分析了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语句块的返回值，并有可能会吞掉异常，代码大忌。