公认的答案在几乎所有方面都是正确的，但它仍然只是事实的一半（好吧，95%的事实）。

假设以下代码：

private final Lock m_Lock = new ReentrantLock();
…
public final SomeObject doSomething( final SomeObject arg )
{
  final SomeObject retValue;
  try
  {
    lock.lock();
    retValue = SomeObject( arg );
  }
  finally
  {
    out.println( "Entering finally block");
    callingAnotherMethod( arg, retValue );
    lock.unlock();
  }
  
  return retValue;
}
…
try
{
   final var result = doSomething( new SomeObject() );
}
catch( final StackOverflowError e ) { /* Deliberately ignored */ }

调用doSomething（）方法将几乎立即导致StackOverflowError。

锁也不会松开！

但是，当finally块总是被执行时（接受的答案中已经列出了例外情况），这怎么会发生呢？

这是因为不能保证finally块中的所有语句都真正执行！

如果在调用lock.unlock（）之前调用System.exit（）或throws语句，这将是显而易见的。

但示例代码中没有类似的内容…

除此之外，调用lock.unlock（）之前finally块中的另外两个方法调用将导致另一个StackOverflowError…

瞧，锁没有松开！

虽然这样的示例代码很愚蠢，但在许多类型的软件中都可以找到类似的模式。只要最后一个街区没有发生什么丑恶的事情，一切都会好起来的…

有趣的事实是，它在Java的更高版本中不起作用（这意味着在更高的版本中，锁被释放了…）。不知道何时以及为什么会发生变化。

但您仍然必须确保finally块始终正常终止，否则它是否始终被执行可能无关紧要…

如果抛出异常，则最终运行。如果未引发异常，则最终运行。如果捕获到异常，则最终运行。如果未捕获异常，则最终运行。

只有当JVM退出时，它才不会运行。

不总是这样

Java语言规范描述了try-catch finally和try-catch块在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不保证在CODE之后执行FIN。JLS保证，如果执行CODE和NEXT，则FIN将始终在CODE之后和NEXT之前执行。

为什么JLS不能保证finally块总是在try块之后执行？因为这是不可能的。在完成try块之后但在执行finally块之前，JVM不太可能被中止（终止、崩溃、断电）。JLS无法避免这种情况。

因此，任何软件的正常行为都取决于最终块，总是在其尝试块完成后执行。

try块中的返回指令与此问题无关。如果执行在try-catch finally之后到达代码，则可以保证finally块之前已经执行过，无论是否在try块内有返回指令。

是的，因为没有控制语句可以阻止finally被执行。

下面是一个参考示例，其中将执行所有代码块：

| x | Current result | Code 
|---|----------------|------ - - -
|   |                |     
|   |                | public static int finallyTest() {
| 3 |                |     int x = 3;
|   |                |     try {
|   |                |        try {
| 4 |                |             x++;
| 4 | return 4       |             return x;
|   |                |         } finally {
| 3 |                |             x--;
| 3 | throw          |             throw new RuntimeException("Ahh!");
|   |                |         }
|   |                |     } catch (RuntimeException e) {
| 4 | return 4       |         return ++x;
|   |                |     } finally {
| 3 |                |         x--;
|   |                |     }
|   |                | }
|   |                |
|---|----------------|------ - - -
|   | Result: 4      |

在下面的变体中，返回x；将跳过。结果仍然是4:

public static int finallyTest() {
    int x = 3;
    try {
        try {
            x++;
            if (true) throw new RuntimeException("Ahh!");
            return x; // skipped
        } finally {
            x--;
        }
    } catch (RuntimeException e) {
        return ++x;
    } finally {
        x--;
    }
}

当然，引用可以跟踪其状态。此示例返回值为4的引用：

static class IntRef { public int value; }
public static IntRef finallyTest() {
    IntRef x = new IntRef();
    x.value = 3;
    try {
        return x;
    } finally {
        x.value++; // will be tracked even after return
    }
}

此外，虽然这是一种糟糕的做法，但如果finally块中有一个return语句，它将胜过常规块中的任何其他返回。也就是说，以下块将返回false：

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

从finally块抛出异常也是一样的。

因为无论你遇到什么情况，总要进行决赛。您没有异常，它仍然被调用，捕获异常，它仍被调用