问题描述
先来看一下以下的代码，猜猜他们会是什么样的结果：
1 public class finallyissue {
2 public static void main(string[] args) {
3 system.out.println("finallyreturntest : ");
4 system.out.println("return value : " finallyreturntest(1));
5 system.out.println("return value : " finallyreturntest(-1));
6
7 system.out.println("finallybreaktest : ");
8 system.out.println("return value : " finallybreaktest(true));
9 system.out.println("return value : " finallybreaktest(false));
10
11 system.out.println("valuechangeinfinallytest : ");
12 system.out.println("return value : " valuechangeinfinallytest());
13
14 system.out.println("valuechangereturninfinallytest : ");
15 system.out.println("return value : " valuechangereturninfinallytest());
16
17 system.out.println("refvaluechangeinfinallytest : ");
18 system.out.println("return name : " refvaluechangeinfinallytest().name);
19 }
20
21 private static boolean finallyreturntest(int value) {
22 try {
23 if(value > 0) {
24 return true;
25 } else {
26 return false;
27 }
28 } finally {
29 return false;
30 }
31 }
32
33 private static boolean finallybreaktest(boolean value) {
34 while(value) {
35 try {
36 return true;
37 } finally {
38 break;
39 }
40 }
41 return false;
42 }
43
44 private static int valuechangeinfinallytest() {
45 int i = 10;
46 int j = 1;
47 try {
48 i = 100;
49 j = 2;
50 system.out.println("try : i = " i);
51 system.out.println("try : j = " j);
52 return i;
53 } catch(exception e) {
54 e.printstacktrace();
55 } finally {
56 i = 1000;
57 j = 3;
58 system.out.println("finally : i = " i);
59 system.out.println("finally : j = " j);
60 }
61
62 return i;
63 }
64
65 private static int valuechangereturninfinallytest() {
66 int i = 10;
67 int j = 1;
68 try {
69 i = 100;
70 j = 2;
71 system.out.println("try : i = " i);
72 system.out.println("try : j = " j);
73 return i;
74 } catch(exception e) {
75 e.printstacktrace();
76 } finally {
77 i = 1000;
78 j = 3;
79 system.out.println("finally : i = " i);
80 system.out.println("finally : j = " j);
81 return i;
82 }
83 }
84
85 private static person refvaluechangeinfinallytest() {
86 person p = new person();
87 try {
88 p.name = "person1";
89 system.out.println("try : person name is : " p.name);
90 return p;
91 } catch(exception e) {
92 e.printstacktrace();
93 } finally {
94 p.name = "person2";
95 system.out.println("finally : person name is : " p.name);
96 }
97
98 p.name = "person3";
99 system.out.println("out : person name is : " p.name);
100
101 return p;
102 }
103
104 static class person {
105 public string name;
106 }
107 }
这样一段代码的结果会是什么呢？
以下是运行结果：
finallyreturntest :
return value : false
return value : false
finallybreaktest :
return value : false
return value : false
valuechangeinfinallytest :
try : i = 100
try : j = 2
finally : i = 1000
finally : j = 3
return value : 100
valuechangereturninfinallytest :
try : i = 100
try : j = 2
finally : i = 1000
finally : j = 3
return value : 1000
refvaluechangeinfinallytest :
try : person name is : person1
finally : person name is : person2
return name : person2
这个结果很出乎我的意料，我们知道finally总是会在try-catch语句块执行完后执行，不管try语句块中是否已经返回或者抛出了异常。
但是在上面的代码测试中，如果finally语句块中有return、break、continue等语句，那么它们会覆盖try语句块中的return、break、continue的语句，如以上的finallyreturntest()、finallybreaktest()、valuechangereturninfinallytest()三个函数。
另外，如果在finally语句块中修改要返回的值类型变量的值，则这些修改不会保存下来，如valuechangeinfinallytest()函数；如果要返回的值是引用类型，则修改引用类型的内部成员的值会保存下来。
如何解释这个结果呢？
问题解释
结合《深入java虚拟机（第二版）》这本书和代码编译后产生的二进制指令代码，我对以上问题做了部分解释，鉴于我的才疏学浅，有些观点是有误的，希望高手指正（有误的观点容易引起误导，这也是所以我一直非常小心，奈何水平有限，有些时候难免出错）。
在《深入java虚拟机（第二版）》的第18章中提到，在早期的java中，finally的行为是通过jsr指令来实现的，并且为这个指令引入了微型子程序的概念。我的理解，所谓微型子程序就是在函数a中嵌入一个不完整的函数b的调用。比如在这本书上的一个例子：
private static int microsubroutine(boolean bvalue) {
try {
if(bvalue) {
return 1;
}
return 0;
} finally {
system.out.println("finally");
}
}
会生成以下的二进制代码：
0 iload_0
1 ifeq 11
4 iconst_1
5 istore_1
6 jsr 24
9 iload_1
10 ireturn
11 iconst_0
12 istore_1
13 jsr 24
16 iload_1
17 ireturn
18 astore_2
19 jsr 24
22 aload_2
23 athrow
24 astore_3
25 getstatic #7
28 ldc #1
30 invokevirtual #8
33 ret 3
如上，24前缀的代码行以后的部分就是微型子程序，在每一个出口之前都会用jsr调用这个微型子例程序，在这个微型子例程序返回（ret）后，返回调用jsr指令的下一条指令，然后返回（ireturn、athrow）。
jsr指令和ret指令的格式如下：
jsr branchbyte1, branchbyte2
把返回地址压栈，跳转至((branchbyte1<<8) | branchbyte2)的位置继续之行。
ret index
返回在index指示的局部变量中存储的值（位置）。
在上面的二进制代码中，每次通过jsr 24跳转到微型子程序，它先将返回地址（jsr 24指令的下一条指令的地址）保存在index为3的局部变量中，执行完微型子程序后，通过ret 3返回到调用jsr 24指令的下一条指令执行，并最终执行返回。
可是后来（有人说是自1.4.2后），jvm中取消了jsr指令了，所有finally内部的代码都内联到源代码中了（二进制的源代码）。所以以上的代码在之后的编译器中会产生如下的二进制代码：
0 iload_0 [bvalue]
1 ifeq 14
4 getstatic java.lang.system.out : java.io.printstream [16]
7 ldc [94]
9 invokevirtual java.io.printstream.println(java.lang.string) : void [24]
12 iconst_1
13 ireturn
14 getstatic java.lang.system.out : java.io.printstream [16]
17 ldc [94]
19 invokevirtual java.io.printstream.println(java.lang.string) : void [24]
22 iconst_0
23 ireturn
24 astore_1
25 getstatic java.lang.system.out : java.io.printstream [16]
28 ldc [94]
30 invokevirtual java.io.printstream.println(java.lang.string) : void [24]
33 aload_1
34 athrow
额，貌似有点偏题了，以上的描述是为了解释《深入java虚拟机（第二版）》中对finally描述过时的描述。下面让我们来真正的解决这个问题。还是从生成的java二进制代码入手。
首先来看一下valuechangeinfinallytest()函数的二进制代码（注释了打印语句，使代码简洁）：
//int i = 10
0 bipush 10
2 istore_0 [i]
//int j = 1
3 iconst_1
4 istore_1 [j]
//i = 100
5 bipush 100
7 istore_0 [i]
//j = 2
8 iconst_2
9 istore_1 [j]
//保存i的值，因为它是要返回的
10 iload_0 [i]
11 istore 4
//--------------------------------内联finally语句块（开始）----------------------
//i = 1000
13 sipush 1000
16 istore_0 [i]
//j = 3
17 iconst_3
18 istore_1 [j]
//--------------------------------内联finally语句块（结束）----------------------
//加载保存后的i的值，并返回。这里返回的是finally语句块执行前的i（由istore 4语句缓存起来）的值，因而在finally语句块中任何对i的操作并不会保留下来。这是在没有异常发生的情况下。
19 iload 4
21 ireturn
22 astore_2 [e]
23 aload_2 [e]
24 invokevirtual java.lang.exception.printstacktrace() : void [104]
//--------------------------------内联finally语句块（开始）----------------------
27 sipush 1000
30 istore_0 [i]
31 iconst_3
32 istore_1 [j]
//--------------------------------内联finally语句块（结束）----------------------
33 goto 45
36 astore_3
//--------------------------------内联finally语句块（开始）----------------------
37 sipush 1000
40 istore_0 [i]
41 iconst_3
42 istore_1 [j]
//--------------------------------内联finally语句块（结束）----------------------
//而在异常发生但没有被正确处理的情况下，返回值已经没有什么意义了。
43 aload_3
44 athrow
//这里是在有异常发生，并且异常得到了正确处理的情况下返回的，此时在finally语句块中对i的操作就会保存下来，并返回给调用者。
45 iload_0 [i]
46 ireturn
相信以上的注释已经能很好的的解决这个问题了（注：这里j的存在是为了证明在内联finally语句块的时候，它只缓存返回值i，而无须缓存其他变量的值，如j的值）。需要特别注意的一点是，如果正常返回的话，finally语句块中修改i的值是保存不下来的，但是如果出现异常，并被正常捕获后，在finally语句块中修改的i的值就会保存下来了。
那么对valuechangereturninfinallytest()函数中的现象如何解释呢？对这个问题解释，首先要理解ireturn的指令。ireturn指令没有操作数，它把当前操作栈的栈顶的int值作为默认的操作数。ireturn指令会弹出当前栈顶的int值，将其压入调用者的操作栈中，同时忽略当前操作栈中的其他值，即函数正常返回。因而如果在不优化的情况下，在finally语句块中的return语句会返回当前栈顶的int值（修改后的i值），然后函数返回，此时栈上的其他操作数就被忽略了，并且原本应该执行的ireturn语句也不会之行了。这种方式甚至会忽略抛出的异常，即使当前方法有异常抛出，它的调用方法还是认为它正常返回了。
如果查看优化后的valuechangereturninfinallytest()方法的二进制源码后，会发现当前的代码更加简洁了。但是它还是没有避免在finally语句块中使用return后，会忽略没有捕获到的异常的问题。
//int i = 10
0 bipush 10
2 istore_0 [i]
//int j = 1
3 iconst_1
4 istore_1 [j]
//i = 100
5 bipush 100
7 istore_0 [i]
//j = 2
8 iconst_2
9 istore_1 [j]
10 goto 22
//catch block
13 astore_2 [e]
14 aload_2 [e]
15 invokevirtual java.lang.exception.printstacktrace() : void [104]
18 goto 22
21 pop
//--------------------------------内联finally语句块（开始）----------------------
//i = 100
22 sipush 1000
25 istore_0 [i]
//j = 3
26 iconst_3
27 istore_1 [j]
//--------------------------------内联finally语句块（结束）----------------------
//返回finally语句块中i的值
28 iload_0 [i]
29 ireturn
经过以上的解释，我想对refvaluechangeinfinallytest()函数中的现象就比较好解释了，因为当进入finally语句块的时候，保存的只是person实例的一个引用，在finally语句块中依然可以通过引用操作person内部成员的，因而在finally语句块中的修改才能保存下来。
而经过编译器优化后的finallyreturntest()和finallybreaktest()函数生成的二进制代码就成一样的了：
0 iload_0 [value]
1 ifeq 8
4 goto 8
7 pop
8 iconst_0
9 ireturn
后记
原本以为这是一个小问题的，没想到花了我一个下午的时间才把问题说清楚了，而在描述问题的过程中，我对问题的本质也看的更加清晰了。这个问题开始是源于我在论坛中看到，感觉论坛里面的人都没很好的说清楚这个问题，刚好我看完了《深入java虚拟机（第二版）》的书，就把这个问题完整的描述出来了。
于2010年9月24日
注：这些文章都是前些时候写的，之前博客很乱，也都是随便贴一些自己写的或转载的，还有一些则是没有贴出来过的。现在打算好好整理一下，完整的记录自己的一些学习历程，而每次看到过去的时间，则让我想起以前的日子，因而我对时间一直是很重视的，所以每篇都著名写的日期，直到最先的文章出现。:)