左右 Java 于 finally 深度分析语句块

首先，让我们来问你一个问题：finally 声明块将运行？

很多人认为 finally 语句块是一定要运行。其中还包括了一些非常有经验的 Java 程序猿。不幸的是，没有像很多像人们想象，对于这个问题，当然，答案是否定的，让我们来看看这个样品之后。

清点1

 public class Test {
      public static void main(String[] args) {
          System.out.println("return value of test(): " + test());
      }
   
      public static int test() {
          int i = 1;
          // if(i == 1)
          // return 0;
         System.out.println("the previous statement of try block");
         i = i / 0;
  
         try {
             System.out.println("try block");
  
             return i;
         } finally {
             System.out.println("finally block");
         }
     }
  
}

清单 1 的运行结果例如以下：

the previous statement of try block Exception in thread "main" java.lang.ArithmeticException: / by zero 
at com.bj.charlie.Test.test(Test.java:15) 
at com.bj.charlie.Test.main(Test.java:6)

 另外。假设去掉上例中被凝视的两条语句前的凝视符，运行结果则是：

return value of test(): 0

在以上两种情况下。finally 语句块都没有运行，说明什么问题呢？
仅仅有与 finally 相相应的 try 语句块得到运行的情况下。finally 语句块才会运行。
以上两种情况，都是在 try 语句块之前返回（return）或者抛出异常，所以 try 相应的 finally 语句块没有运行。

那好，即使与 finally 相相应的 try 语句块得到运行的情况下，finally 语句块一定会运行吗？
请看以下这个样例（清单 2）。

清单2

public class Test {
      public static void main(String[] args) {
          System.out.println("return value of test(): " + test());
      }
   
      public static int test() {
          int i = 1;
   
          try {
             System.out.println("try block");
             System.exit(0);
  
             return i;
         } finally {
             System.out.println("finally block");
         }
     }
}

清单 2 的运行结果例如以下：

try blocktry block

finally 语句块还是没有运行，为什么呢？

由于我们在 try 语句块中执行了 System.exit (0) 语句。终止了 Java 虚拟机的执行。
 
那有人说了。在一般的 Java 应用中基本上是不会调用这个 System.exit(0) 方法的。
OK ！没有问题，我们不调用 System.exit(0) 这种方法，那么 finally 语句块就一定会运行吗？

答案还是否定的。

当一个线程在运行 try 语句块或者 catch 语句块时被打断（interrupted）或者被终止（killed）。与其相相应的 finally 语句块可能不会运行。
还有更极端的情况，就是在线程执行 try 语句块或者 catch 语句块时，突然死机或者断电，finally 语句块肯定不会执行了。

可能有人觉得死机、断电这些理由有些强词夺理，没有关系，我们仅仅是为了说明这个问题。
 

finally 语句演示样例说明

以下，我们先来看一个简单的样例（清单 3）。

清单 3.

 public class Test {
     public static void main(String[] args) {
         try {
             System.out.println("try block");
  
             return;
         } finally {
             System.out.println("finally block");
         }
    }
}

清单 3 的运行结果为：

try block 
finally block

 

清单 3 说明 finally 语句块在 try 语句块中的 return 语句之前运行

 
我们再来看还有一个样例

清单 4.

public class Test {
    public static void main(String[] args) {
        System.out.println("reture value of test() : " + test());
    }
 
    public static int test() {
        int i = 1;
 
        try {
            System.out.println("try block");
            i = 1 / 0;
  
            return 1;
        } catch (Exception e) {
            System.out.println("exception block");
 
            return 2;
        } finally {
            System.out.println("finally block");
        }
    }
}

清单 4 的运行结果为：

try block
exception block 
finally block 
reture value of test() : 2

清单 4 说明了 finally 语句块在 catch 语句块中的 return 语句之前运行。

从上面的清单 3 和清单 4。我们能够看出，

事实上 finally 语句块是在 try 或者 catch 中的 return 语句之前运行的。

更加一般的说法是，finally 语句块应该是在控制转移语句之前运行，控制转移语句除了 return 外。还有 break 和 continue。
另外，throw 语句也属于控制转移语句。尽管 return、throw、break 和 continue 都是控制转移语句，可是它们之间是有差别的。

当中 return 和 throw 把程序控制权转交给它们的调用者（invoker），而 break 和 continue 的控制权是在当前方法内转移。

清单 5.

public class Test {
     public static void main(String[] args) {
         System.out.println("return value of getValue(): " + getValue());
     }
  
     public static int getValue() {
         try {
             return 0;
         } finally {
             return 1;
         }
     }
 }

 清单 5 的运行结果：

return value of getValue(): 1

清单 6. 

  public class Test {
      public static void main(String[] args) {
          System.out.println("return value of getValue(): " + getValue());
      }
   
      public static int getValue() {
          int i = 1;
   
          try {
             return i;
        } finally {
             i++;
         }
     }
 }  

清单 6 的运行结果：

return value of getValue(): 1

 

利用我们上面分析得出的结论：

finally 语句块是在 try 或者 catch 中的 return 语句之前运行的。

 

由此，能够轻松的理解清单 5 的运行结果是 1。

由于 finally 中的 return 1。语句要在 try 中的 return 0。语句之前运行。那么 finally 中的 return 1。
语句运行后。把程序的控制权转交给了它的调用者 main（）函数，而且返回值为 1。

那为什么清单 6 的返回值不是 2，而是 1 呢？

依照清单 5 的分析逻辑，finally 中的 i++；
语句应该在 try 中的 return i；之前运行啊？ 
i 的初始值为 1，那么运行 i++；之后为 2。再运行 return i。那不就应该是 2 吗？怎么变成 1 了呢？
 

我们来分析一下其运行顺序：分为正常运行（没有 exception）和异常运行（有 exception）两种情况。我们先来看一下正常运行的情况。如图 1 所看到的：

图 1. getValue（）函数正常运行的情况

由上图，我们能够清晰的看出，在 finally 语句块（iinc 0, 1）运行之前，getValue（）方法保存了其返回值（1）到本地表量表中 1 的位置。完毕这个任务的指令是 istore_1；然后运行 finally 语句块（iinc 0, 1）。finally 语句块把位于 0 这个位置的本地变量表中的值加 1。变成 2；待 finally 语句块运行完毕之后。把本地表量表中 1 的位置上值恢复到操作数栈（iload_1），最后运行 ireturn 指令把当前操作数栈中的值（1）返回给其调用者（main）。这就是为什么清单 6 的运行结果是 1，而不是 2 的原因。

再让我们来看看异常运行的情况。是不是有人会问。你的清单 6 中都没有 catch 语句，哪来的异常处理呢？我认为这是一个好问题，事实上。即使没有 catch 语句。Java 编译器编译出的字节码中还是有默认的异常处理的。别忘了，除了须要捕获的异常，还可能有不需捕获的异常（如：RunTimeException 和 Error）。

图 2. getValue（）函数异常运行的情况

清单 7. 

  public class Test {
      public static void main(String[] args) {
          System.out.println("return value of getValue(): " + getValue());
      }
   
      @SuppressWarnings("finally")
      public static int getValue() {
          int i = 1;
   
         try {
             i = 4;
        } finally {
             i++;

             return i;
         }
     }
}

清单 7 的运行结果：

return value of getValue(): 5

清单 8.

public class Test {
     public static void main(String[] args) {
          System.out.println("return value of getValue(): " + getValue());
      }
   
      public static int getValue() {
          int i = 1;
   
          try {
             i = 4;
         } finally {
             i++;
         }
  
         return i;
     }
}

清单 8 的运行结果：

return value of getValue(): 5

让我们再来看一个略微复杂一点的样例 – 清单 9。

清单 9.

public class Test {
      public static void main(String[] args) {
          System.out.println(test());
      }
   
      public static String test() {
          try {
              System.out.println("try block");
   
             return test1();
         } finally {
             System.out.println("finally block");
         }
     }
  
     public static String test1() {
         System.out.println("return statement");
  
         return "after return";
     }
}

清单 9 的结果：

try block 
return statement
finally block 
after return

return test1();这条语句等同于 :

String tmp = test1(); return tmp;

 

这项。应当清楚为什么结果所见上方的栏。

版权声明：本文博主原创文章。博客，未经同意不得转载。