Java 中的finally 块总是被执行吗？

Question

考虑到这段代码，我是否可以绝对确定 finally 块始终执行，无论 something() 是什么？

try {  
    something();  
    return success;  
}  
catch (Exception e) {   
    return failure;  
}  
finally {  
    System.out.println("I don't know if this will get printed out");
}

Answer 1

是的，finally 将在执行 try 或 catch 代码块后被调用。

唯一不会调用 finally 的情况是：

1. 如果您调用 System.exit()
2. 如果您调用 Runtime.getRuntime().halt(exitStatus)< /code>
3. 如果 JVM 首先崩溃
4. 如果 JVM 在 try 或 catch 块中达到无限循环（或其他一些不可中断、非终止语句）
5. 如果OS强制终止JVM进程； 例如，UNIX 上的 kill -9
6. 如果主机系统死机； 例如，电源故障、硬件错误、操作系统恐慌等
7. 如果finally块将由守护线程执行，并且所有其他非守护线程在finally之前退出叫做

Answer 2

最后的返回也会抛出任何异常。 http://jamesjava.blogspot.com/2006/03 /dont-return-in-finally-clause.html

Answer 3

finally 总是被执行，除非程序异常终止（比如调用 System.exit(0)）。 因此，您的 System.out 将被打印。

Answer 4

除非出现异常程序终止（由于 JVM 崩溃或调用 System.exit(0) 导致），否则 Final 块始终会执行。

最重要的是，从finally块中返回的任何值都将覆盖执行finally块之前返回的值，因此在使用tryfinally时要小心检查所有退出点。

Answer 5

不，并非总是如此，一种例外情况是
System.exit(0);
在 finally 块之前阻止执行 finally。

      class A {
        public static void main(String args[]) {
            DataInputStream cin = new DataInputStream(System.in);

            try {
                int i = Integer.parseInt(cin.readLine());
            } catch (ArithmeticException e) {
            } catch (Exception e) {
               System.exit(0); // Program terminates before executing the finally block
            } finally {
                System.out.println("Won't be executed");
                System.out.println("No error");
            }
        }
    }

Answer 6

这就是finally 块的全部思想。 当然，它可以让您确保进行清理工作，否则这些清理工作可能会因为您返回而被跳过。

无论 try 块中发生什么，finally 都会被调用（除非您调用 System.exit(int) 或 Java 虚拟机退出其他一些原因）。

Answer 7

思考这个问题的逻辑方法是：

1. 放置在finally块中的代码必须在try块中无论发生什么执行
2. 因此，如果try块中的代码尝试返回一个值或抛出一个异常，则该项目是放在“架子上”直到finally块可以执行
3. 因为finally块中的代码（根据定义）具有高优先级，它可以返回或抛出任何它喜欢的东西。 在这种情况下，“架子上”留下的任何东西都会被丢弃。
4. 唯一的例外是虚拟机在 try 块期间完全关闭，例如通过“System.exit”

Answer 8

以下是凯文的回答的详细阐述。 重要的是要知道要返回的表达式是在 finally 之前计算的，即使它是在之后返回的。

public static void main(String[] args) {
    System.out.println(Test.test());
}

public static int printX() {
    System.out.println("X");
    return 0;
}

public static int test() {
    try {
        return printX();
    }
    finally {
        System.out.println("finally trumps return... sort of");
        return 42;
    }
}

输出：

X
finally trumps return... sort of
42

Answer 9

我尝试了上面的例子，稍加修改 -

public static void main(final String[] args) {
    System.out.println(test());
}

public static int test() {
    int i = 0;
    try {
        i = 2;
        return i;
    } finally {
        i = 12;
        System.out.println("finally trumps return.");
    }
}

上面的代码输出：

终于战胜了回归。
2

这是因为当执行 return i; 时，i 的值为 2。此后执行 finally 块，其中 12 被分配给 < code>i 然后执行 System.out out。

执行finally 块后，try 块返回2，而不是返回12，因为该return 语句不会再次执行。

如果您在 Eclipse 中调试这段代码，那么您会感觉到，在执行 finally 的 System.out 后，会阻塞 return 语句。 code>try 块再次执行。 但这种情况并非如此。 它只是返回值 2。

Answer 10

除了其他响应之外，重要的是要指出“finally”有权通过 try..catch 块覆盖任何异常/返回值。 例如，以下代码返回 12：

public static int getMonthsInYear() {
    try {
        return 10;
    }
    finally {
        return 12;
    }
}

类似地，以下方法不会引发异常：

public static int getMonthsInYear() {
    try {
        throw new RuntimeException();
    }
    finally {
        return 12;
    }
}

而以下方法会引发异常：

public static int getMonthsInYear() {
    try {
        return 12;          
    }
    finally {
        throw new RuntimeException();
    }
}

Answer 11

示例代码：

public static void main(String[] args) {
    System.out.println(Test.test());
}

public static int test() {
    try {
        return 0;
    }
    finally {
        System.out.println("something is printed");
    }
}

输出：

something is printed. 
0

Answer 12

另外，尽管这是不好的做法，但如果 finally 块中有 return 语句，它将胜过常规块中的任何其他返回。 也就是说，以下块将返回 false：

try { return true; } finally { return false; }

与从 finally 块抛出异常相同。

Answer 13

以下是 Java 语言规范的官方措辞。

14.20.2。 try-finally 和 try-catch-finally 的执行

带有 finally 块的 try 语句首先执行 try 块来执行。 然后有一个选择：

• 如果 try 块的执行正常完成，[...]
• 如果 try 块的执行由于 V 值的 throw 突然完成，[...]
• 如果 try 块的执行由于任何其他原因突然完成R，则执行 finally 块。 然后有一个选择：
  • 如果finally 块正常完成，则try 语句会由于R 的原因突然完成。
  • 如果 finally 块因 S 原因突然完成，则 try 语句因 S 原因突然完成（以及R被丢弃的原因）。

return 的规范实际上明确了这一点：

JLS 14.17 退货声明

返回语句： 
       返回表达式（选择）； 
  

没有表达式的return语句尝试将控制转移到包含它的方法或构造函数的调用者。

带有表达式的return语句尝试将控制权转移到包含它的方法的调用者； Expression 的值成为方法调用的值。

前面的描述说的是“尝试转移控制权”，而不仅仅是“转移控制权”，因为如果有任何尝试方法或构造函数中的 语句，其 try 块包含 return 语句，然后是这些 try< 的任何 finally 子句在控制权转移到方法或构造函数的调用者之前， /code> 语句将按从最内层到最外层的顺序执行。 finally 子句的突然完成可能会中断 return 语句启动的控制权转移。




Answer 14

最后总是运行，这就是重点，仅仅因为它出现在返回之后的代码中并不意味着这就是它的实现方式。 Java 运行时有责任在退出 try 块时运行此代码。

例如，如果您有以下内容：

int foo() { 
    try {
        return 42;
    }
    finally {
        System.out.println("done");
    }
}

运行时将生成如下内容：

int foo() {
    int ret = 42;
    System.out.println("done");
    return 42;
}

如果抛出未捕获的异常，finally 块将运行并且异常将继续传播。

Answer 15

因为除非你调用 System.exit() （或者线程崩溃），否则finally 块将始终被调用。

Answer 16

简而言之，在官方 Java 文档（点击此处）中，写道——

如果在执行 try 或 catch 代码时 JVM 退出，则
finally 块可能不会执行。 同样，如果线程执行
try 或 catch 代码被中断或终止，finally 块可能
即使应用程序作为一个整体继续运行，也不会执行。

Answer 17

这是因为您将 i 的值指定为 12，但没有将 i 的值返回给函数。 正确的代码如下：

public static int test() {
    int i = 0;
    try {
        return i;
    } finally {
        i = 12;
        System.out.println("finally trumps return.");
        return i;
    }
}

Answer 18

是的，它会被调用。 这就是finally 关键字的全部意义所在。 如果跳出 try/catch 块可以跳过 finally 块，则与将 System.out.println 放在 try/catch 之外是一样的。

Answer 19

并不总是

Java 语言规范描述了 try-catch-finally 和 try-catch 的方式code> 块在 14.20 工作.2
它没有在任何地方指定始终执行 finally 块。
但对于 try-catch-finally 和 try-finally 的所有情况> 块完成它确实指定在完成之前必须执行finally。

try {
  CODE inside the try block
}
finally {
  FIN code inside finally block
}
NEXT code executed after the try-finally block (may be in a different method).

JLS 不保证FIN 在CODE 之后执行。
JLS 保证如果执行CODE 和NEXT，则FIN 将始终在CODE 之后和之前执行。 >下一步。

为什么 JLS 不保证 finally 块始终在 try 块之后执行？ 因为这是不可能的。 JVM 在完成 try 块之后但在执行 之前，不太可能但有可能中止（终止、崩溃、断电）。 code>finally 块。 JLS 无法采取任何措施来避免这种情况。

因此，任何依赖于总是在 try 块完成后执行的 finally 块来正常运行的软件都会被窃听。

try 块中的 return 指令与此问题无关。 如果执行到 try-catch-finally 之后的代码，则保证 finally 块将被执行之前，在 try 块内有或没有 return 指令。

Answer 20

finally 块始终在返回 x 的（计算出的）值之前执行。

System.out.println("x value from foo() = " + foo());

...

int foo() {
  int x = 2;
  try {
    return x++;
  } finally {
    System.out.println("x value in finally = " + x);
  }
}

输出：

最后的 x 值 = 3
foo() 的 x 值 = 2

Answer 21

答案很简单是。

输入：

try{
    int divideByZeroException = 5 / 0;
} catch (Exception e) {
    System.out.println("catch");
    return;    // also tried with break; in switch-case, got same output
} finally {
    System.out.println("finally");
}

输出：

catch
finally

Answer 22

是的，它会。 无论 try 或 catch 块中发生什么，除非调用 System.exit() 或 JVM 崩溃。 如果块中有任何 return 语句，finally 将在该 return 语句之前执行。

Answer 23

是的，它会。
唯一不会出现的情况是 JVM 退出或崩溃

Answer 24

添加到 @vibhash 的答案，因为没有其他答案解释了在像下面这样的可变对象的情况下会发生什么。

public static void main(String[] args) {
    System.out.println(test().toString());
}

public static StringBuffer test() {
    StringBuffer s = new StringBuffer();
    try {
        s.append("sb");
        return s;
    } finally {
        s.append("updated ");
    }
}

会输出

sb更新  
  

Answer 25

是的，finally 块总是被执行。 大多数开发人员使用此块来关闭数据库连接、结果集对象、语句对象，并且还使用 java hibernate 来回滚事务。

Answer 26

我对不同论坛上提供的所有答案感到非常困惑，并决定最终编码并查看。 输出是：

即使 try 和 catch 块中有 return，finally 也会被执行。

try {  
  System.out.println("try"); 
  return;
  //int  i =5/0;
  //System.exit(0 ) ;
} catch (Exception e) {   
  System.out.println("catch");
  return;
  //int  i =5/0;
  //System.exit(0 ) ;
} finally {  
   System.out.println("Print me FINALLY");
}

输出

尝试

最后打印我

2. 如果上面代码中的 try 和 catch 块中的 return 被替换为 System.exit(0) ，并且无论出于何种原因，在它之前发生了异常。

Answer 27

finally 将会执行，这是肯定的。

finally 在以下情况下不会执行：

情况 1：

当您执行 System.exit() 时。

情况 2：

当您的 JVM/线程崩溃时。

情况 3：

当您手动停止执行时。

Answer 28

我试过这个，
它是单线程的。

public static void main(String args[]) throws Exception {
    Object obj = new Object();
    try {
        synchronized (obj) {
            obj.wait();
            System.out.println("after wait()");
        }
    } catch (Exception ignored) {
    } finally {
        System.out.println("finally");
    }
}

main Thread 将永远处于 wait 状态，因此 finally 永远不会被调用，

因此控制台输出不会 print String：在 wait() 或 finally

同意@Stephen C，上面的例子是这里提到的第三种情况之一：

在以下代码中添加更多这样的无限循环可能性：

// import java.util.concurrent.Semaphore;

public static void main(String[] args) {
    try {
        // Thread.sleep(Long.MAX_VALUE);
        // Thread.currentThread().join();
        // new Semaphore(0).acquire();
        // while (true){}
        System.out.println("after sleep join semaphore exit infinite while loop");
    } catch (Exception ignored) {
    } finally {
        System.out.println("finally");
    }
}

情况2：如果 JVM 首先崩溃

import sun.misc.Unsafe;
import java.lang.reflect.Field;

public static void main(String args[]) {
    try {
        unsafeMethod();
        //Runtime.getRuntime().halt(123);
        System.out.println("After Jvm Crash!");
    } catch (Exception e) {
    } finally {
        System.out.println("finally");
    }
}

private static void unsafeMethod() throws NoSuchFieldException, IllegalAccessException {
    Field f = Unsafe.class.getDeclaredField("theUnsafe");
    f.setAccessible(true);
    Unsafe unsafe = (Unsafe) f.get(null);
    unsafe.putAddress(0, 0);
}

参考：如何使 JVM 崩溃？

案例 6：如果最后 block 将由守护进程 Thread 执行，所有其他非守护进程 Threads 在调用 finally 之前退出。

public static void main(String args[]) {
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            try {
                printThreads("Daemon Thread printing");
                // just to ensure this thread will live longer than main thread
                Thread.sleep(10000);
            } catch (Exception e) {
            } finally {
                System.out.println("finally");
            }
        }
    };
    Thread daemonThread = new Thread(runnable);
    daemonThread.setDaemon(Boolean.TRUE);
    daemonThread.setName("My Daemon Thread");
    daemonThread.start();
    printThreads("main Thread Printing");
}

private static synchronized void printThreads(String str) {
    System.out.println(str);
    int threadCount = 0;
    Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
    for (Thread t : threadSet) {
        if (t.getThreadGroup() == Thread.currentThread().getThreadGroup()) {
            System.out.println("Thread :" + t + ":" + "state:" + t.getState());
            ++threadCount;
        }
    }
    System.out.println("Thread count started by Main thread:" + threadCount);
    System.out.println("-------------------------------------------------");
}

输出：这不会打印“finally”，这意味着“守护线程”中的“Finally block”没有执行

主线程打印   
  线程：线程[我的守护程序线程，5，主]：状态：BLOCKED   
  线程：线程[主，5，主]：状态：RUNNABLE   
  线程：线程[监视器 Ctrl-Break,5,main]:状态:RUNNABLE    
  主线程启动的线程数：3   
  -------------------------------------------------   
  守护线程打印   
  线程：线程[我的守护程序线程，5，主]：状态：RUNNABLE   
  线程：线程[监视器 Ctrl-Break,5,main]:状态:RUNNABLE   
  主线程启动的线程数：2   
  -------------------------------------------------   

  进程已完成，退出代码为 0 
  

Answer 29

考虑以下程序：

public class SomeTest {

    private static StringBuilder sb = new StringBuilder();

    public static void main(String args[]) {

        System.out.println(someString());
        System.out.println("---AGAIN---");
        System.out.println(someString());
        System.out.println("---PRINT THE RESULT---");
        System.out.println(sb.toString());
    }

    private static String someString() {

        try {
            sb.append("-abc-");
            return sb.toString();

        } finally {
            sb.append("xyz");
        }
    }
}

从 Java 1.8.162 开始，上述代码块给出以下输出：

-abc-
---AGAIN---
-abc-xyz-abc-
---PRINT THE RESULT---
-abc-xyz-abc-xyz

这意味着使用 finally 来释放对象是一个很好的做法，如下代码所示：

private static String someString() {

    StringBuilder sb = new StringBuilder();

    try {
        sb.append("abc");
        return sb.toString();

    } finally {
        sb = null; // Just an example, but you can close streams or DB connections this way.
    }
}

Answer 30

这实际上在任何语言中都是如此......finally 总是在 return 语句之前执行，无论 return 位于方法体中的哪个位置。 如果不是这样，finally 块就没有多大意义。