上善若水
In general the OO style is to use a lot of little objects with a lot of little methods that give us a lot of plug points for overriding and variation. To do is to be -Nietzsche, To bei is to do -Kant, Do be do be do -Sinatra
posts - 146,comments - 147,trackbacks - 0

问题描述

先来看一下以下的代码,猜猜他们会是什么样的结果:

  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语句块中有returnbreakcontinue等语句,那么它们会覆盖try语句块中的returnbreakcontinue的语句,如以上的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 <Field java.io.PrintStream out>

28 ldc #1 <String “finally”>

30 invokevirtual #8 <Method void println(java.lang.String)>

33 ret 3

 

如上,24前缀的代码行以后的部分就是微型子程序,在每一个出口之前都会用JSR调用这个微型子例程序,在这个微型子例程序返回(ret)后,返回调用JSR指令的下一条指令,然后返回(ireturnathrow)。

jsr指令和ret指令的格式如下:

jsr    branchbyte1, branchbyte2

把返回地址压栈,跳转至((branchbyte1<<8) | branchbyte2)的位置继续之行。

ret index

返回在index指示的局部变量中存储的值(位置)。

 

在上面的二进制代码中,每次通过jsr 24跳转到微型子程序,它先将返回地址(jsr 24指令的下一条指令的地址)保存在index3的局部变量中,执行完微型子程序后,通过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 <String "finally"> [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 <String "finally"> [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 <String "finally"> [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

 

后记

原本以为这是一个小问题的,没想到花了我一个下午的时间才把问题说清楚了,而在描述问题的过程中,我对问题的本质也看的更加清晰了。这个问题开始是源于我在论坛http://www.javaeye.com/topic/458668中看到,感觉论坛里面的人都没很好的说清楚这个问题,刚好我看完了《深入Java虚拟机(第二版)》的书,就把这个问题完整的描述出来了。

                                                                                                                                                                         于2010年9月24日

注:这些文章都是前些时候写的,之前博客很乱,也都是随便贴一些自己写的或转载的,还有一些则是没有贴出来过的。现在打算好好整理一下,完整的记录自己的一些学习历程,而每次看到过去的时间,则让我想起以前的日子,因而我对时间一直是很重视的,所以每篇都著名写的日期,直到最先的文章出现。:)
posted on 2011-06-24 22:37 DLevin 阅读(2361) 评论(5)  编辑  收藏

FeedBack:
# re: finally知多少
2011-06-25 22:17 | CodePro
不错,很深入  回复  更多评论
  
# re: finally知多少
2011-06-28 09:38 | hongfeng-Maple
还是很不错的哈  回复  更多评论
  
# re: finally知多少
2011-06-28 14:44 | 雷斌辉
不错 不错  回复  更多评论
  
# re: finally知多少[未登录]
2011-10-16 18:18 | chris
这些天在学习字节码相关的东东,很感谢楼主的分享,采用JDK1.6编译了一下楼主的代码,发现一下诡异的问题:
//加载保存后的i的值,并返回。这里返回的是finally语句块执行前的i(由istore 4语句缓存起来)的值,因而在finally语句块中任何对i的操作并不会保留下来。这是在没有异常发生的情况下。

19 iload 4
21 ireturn

我的控制台显示的iload0, 就是说返回的是经过finally语句赋值后的i, 而并不是在try块中的i, 在eclipse调试运行得出的也是相同的结果,不知是怎么回事  回复  更多评论
  
# re: finally知多少[未登录]
2011-10-16 18:37 | chris
抱歉,楼主是对的,我运行的是函数valueChangeReturnInFinallyTest,差别是如果finally里面有return语句的情况下,最终返回的是经过finally修改的值,在此情况下执行的字节码为:
iload0
ireturn
否则返回的为try块中的值,执行的字节码为
iload4
ireturn  回复  更多评论
  

只有注册用户登录后才能发表评论。


网站导航: