How to stop execution of the finally block in Java

In Java, the finally block is always executed after the try block (and optionally, the catch block) regardless of whether an exception occurs or not. However, there are certain ways to “stop” or skip the execution of the finally block under specific circumstances. These involve drastic measures and should generally be avoided unless absolutely necessary, as they can lead to non-standard and unpredictable behavior.

Here are different ways:

---

1. Using System.exit()

If System.exit(int) is called in the try or catch block, it terminates the program, and the finally block will not be executed.

public class FinallySkipExample {
    public static void main(String[] args) {
        try {
            System.out.println("Inside try block");
            System.exit(0); // Terminates the program
        } finally {
            System.out.println("Inside finally block"); // This will not execute
        }
    }
}

Output:

Inside try block

---

2. Thread Interruption

If the thread running the try-finally block is forcefully stopped (e.g., deprecated methods like Thread.stop()), the finally block may not execute.

public class FinallySkipExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                System.out.println("Inside try block");
                Thread.currentThread().stop(); // Forcefully stops the thread
            } finally {
                System.out.println("Inside finally block"); // This may not execute
            }
        });

        thread.start();
    }
}

Warning: Thread.stop() is deprecated because it can cause unpredictable behavior and leave resources in an inconsistent state.

---

3. Infinite Loop or Exception in Finally Block

If an infinite loop is introduced in the try or catch block before the finally block is reached, the program will hang, effectively preventing the finally block from executing.

public class FinallySkipExample {
    public static void main(String[] args) {
        try {
            while (true) { // Infinite loop
                System.out.println("Infinite loop in try block");
            }
        } finally {
            System.out.println("Inside finally block"); // This will never execute
        }
    }
}

---

4. Crash the JVM

If the JVM crashes due to some catastrophic error (e.g., a StackOverflowError or OutOfMemoryError), the finally block will not execute.

public class FinallySkipExample {
    public static void main(String[] args) {
        try {
            System.out.println("Inside try block");
            throw new StackOverflowError(); // Crashes the JVM
        } finally {
            System.out.println("Inside finally block"); // This will not execute
        }
    }
}

---

5. Daemon Thread Termination

If the code is running in a daemon thread, and all user threads finish execution before the daemon thread reaches the finally block, the daemon thread will terminate without executing the finally block.

public class FinallySkipExample {
    public static void main(String[] args) {
        Thread daemonThread = new Thread(() -> {
            try {
                System.out.println("Inside try block");
            } finally {
                System.out.println("Inside finally block"); // May not execute if JVM terminates
            }
        });
        daemonThread.setDaemon(true);
        daemonThread.start();

        System.out.println("Main thread ends"); // JVM may exit before daemon thread finishes
    }
}

---

Summary Table:

Best Practices

While it is possible to stop the finally block execution, it is highly discouraged. The finally block is meant to release resources, such as closing files, sockets, or database connections. Disrupting its execution can leave your application in an inconsistent or unstable state.