无论异常处理与否，Finally块始终执行。如果在try块之前发生任何异常，那么Finally块将不会执行。

如果在嵌套的finally块中引发异常，finally也可以提前退出。编译器会警告你finally块没有正常完成，或者给出一个错误，说明你有无法访问的代码。仅当抛出不在条件语句后面或循环内部时，才会显示不可访问代码的错误。

try{
}finally{
   try{
   }finally{
      //if(someCondition) --> no error because of unreachable code
      throw new RunTimeException();
   }
   int a = 5;//unreachable code
}

下面是凯文的回答。重要的是要知道，要返回的表达式在finally之前求值，即使在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

是的，总是执行finally块。大多数开发人员使用此块来关闭数据库连接、resultset对象、语句对象，还使用到java休眠来回滚事务。

除了最后替换try块中的返回之外，异常也是如此。引发异常的finally块将替换try块中引发的返回或异常。

我试过了，它是单线程的。

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");
    }
}

主线程将永远处于等待状态，因此最终不会被调用，

因此控制台输出不会在wait（）或finally之后打印String:

同意@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：如果finally块将由守护程序线程执行，并且所有其他非守护程序线程在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块”没有执行

主螺纹打印线程：线程[My Daemon线程，5，main]：状态：BLOCKED线程：线程[main，5，main]：状态：RUNNABLE线程：线程[Monitor Ctrl-Break，5，main]：状态：RUNNABLE主线程启动的线程计数：3------------------------------------------------- Daemon线程打印线程：线程[My Daemon线程，5，main]：状态：RUNNABLE线程：线程[Monitor Ctrl-Break，5，main]：状态：RUNNABLE主线程启动的线程计数：2------------------------------------------------- 进程已完成，退出代码为0