Exception loss and return value overwrite parsing for JAVA finally words

Reprint: http://blog.csdn.net/sureyonder/article/details/5560538

The Java Virtual machine "calls" the subroutine of the finally clause at the end of each try statement block and its associated catch clause. In fact, the finally clause behaves very much like a "mini-subroutine" inside a method. After the finally clause has ended normally-that is, the last statement in the finally clause is executed properly, excluding throwing an exception, or performing a return, continue, break, and so on, the mini-subroutine that is subordinate to the finally clause performs a "return" operation. The program resumes execution of the following statement where the mini-subroutine was first called.

The finally "miniature subroutine" is not equivalent to a call to a method function, and the finally clause is executed within the same stack, and the "return" operation of the mini-subroutine does not involve the method fallback, just to make the program counter PC jump to a different location of the same method to continue execution.

An abnormal loss

[Java]View Plaincopy

2. Public static void Exceptionlost ()
4. {
6. Try
8. {
10. Try
12. {
14. throw New Exception ( "Exception in Try");
16. }
18. finally
20. {
22. throw New Exception ( "Exception in finally");
24. }
26. }
28. catch (Exception e)
30. {
32. System.out.println (e);
34. }
36. }

The output of Exceptionlost () is "exception in finally" rather than the exception thrown in the try block, which is a flaw in the Java exception mechanism-exception loss.

In bytecode, the throw statement is not an atomic operation. In older JDK, the throw statement of the try block in Exceptionlost () is decomposed into several steps:

1) Store the exception ("Exception in Try") object reference in a local variable
astore_2//Pop the reference to the thrown exception, store into local variable 2
2) Call finally mini-subroutine
3) Push the exception ("Exception in Try") object reference in the local variable to the top of the operand stack and throw an exception
Aload_2//Push the reference to the thrown exception from local variable 2

Athrow//Throw the exception

If finally exits by break, return, continue, or throws an exception, then the 3rd step above will not be executed.

In JDK1.6, we can see by bytecode that the finally clause is implemented as a special catch, and the following is the exception table for the Exceptionlost () method:

Exception table:
From to target type
0 any
0 Class Java/lang/exception

Finally, you can catch any type of exception that is thrown from 0 rows to 9 rows and either re-throw the caught exception, or throw a new exception that you construct, which overwrites the exception in the TRY statement block.

Two return value overrides

[Java]View Plaincopy

2. Public static int getValue ()
4. {
6. int value = 0;
10. Try
12. {
14. value = 100;
18. return value;
20. }
22. finally
24. {
26. Value = 200;
28. }
30. }

is the return value of this method 100 or 200? The result is 100.
In bytecode, the return statement is not an atomic operation, it decomposes the return statement in GetValue () into several steps:
1) Store the value values in a local variable (named temp here):
ILOAD_0//PUSH local variable 0-the 100
istore_2//Pop an int., store into local varaible 2
2) Call finally mini-subroutine
3) Push the value of the local variable (referred to as temp) to the top of the operand stack and return to the calling method
Iload_2//Push local varaible 2-the 100
Ireturn//return int on top of the stack-the 100:return 100

Because the return statement saves the returned value to a temporary local variable before it returns, the value is re-assigned within the FINALLY clause without affecting the return value.

Understanding some of the inner knowledge of the finally clause allows us to understand what finally can and cannot do, which will help us to use the finally clause correctly.

Exception loss and return value overwrite parsing for JAVA finally words