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

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

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

try-catch-finally是使用异常处理案例的关键词。作为正常外植体

try {
     //code statements
     //exception thrown here
     //lines not reached if exception thrown
} catch (Exception e) {
    //lines reached only when exception is thrown
} finally {
    // always executed when the try block is exited
    //independent of an exception thrown or not
}

finally块阻止执行。。。

调用System.exit（0）时；如果JVM退出。JVM中的错误

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

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

答案很简单：是。

输入：

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

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