Что позволяет не вызывать блок finally?

Что позволяет не вызывать блок finally

Вопрос очень похож на ранее рассмотренный, но сфокусирован на всех способах, которыми finally может быть пропущен. Давай разберёмся во всех сценариях.

Основные способы, когда finally НЕ вызывается

1. System.exit()

Самый известный способ:

public class SystemExitExample {
    public static void main(String[] args) {
        try {
            System.out.println("try");
            System.exit(0);
        } finally {
            System.out.println("finally"); // НЕ ВЫВЕДЕТСЯ
        }
    }
}

SYSTEM.exit() немедленно прерывает JVM, не выполняя finally.

2. Runtime.getRuntime().halt()

Ещё более агрессивный способ (force halt):

public class HaltExample {
    public static void main(String[] args) {
        try {
            Runtime.getRuntime().halt(1);
        } finally {
            System.out.println("finally"); // НЕ ВЫВЕДЕТСЯ
        }
    }
}

RuntimeException в shutdown hook тоже может предотвратить выполнение finally.

3. Бесконечный loop в try

Если код зависает в цикле, finally не будет вызван:

public class InfiniteLoopExample {
    public static void main(String[] args) {
        try {
            while (true) {
                // Бесконечный цикл, finally не достигнется
            }
        } finally {
            System.out.println("finally"); // НЕ ВЫВЕДЕТСЯ
        }
    }
}

4. Крах JVM (SIGSEGV)

Если JVM получит сигнал крша (segmentation fault):

public class JvmCrashExample {
    public static void main(String[] args) {
        try {
            // Вызвать native code, который крашит JVM
            // Например, через reflection или JNI
        } finally {
            System.out.println("finally"); // МОЖЕТ НЕ ВЫВЕДЕТСЯ
        }
    }
}

5. OutOfMemoryError (иногда)

Если JVM не может выделить память для выполнения finally:

public class OOMExample {
    public static void main(String[] args) {
        try {
            List<byte[]> list = new ArrayList<>();
            while (true) {
                list.add(new byte[1024 * 1024]); // 1MB chunks
            }
        } catch (OutOfMemoryError e) {
            System.out.println("OOM");
        } finally {
            System.out.println("finally"); // МОЖЕТ выполниться
        }
    }
}

В большинстве случаев finally всё равно выполнится, но в экстремальных ситуациях может и не выполниться.

6. Поток был убит извне

Если поток прерван на OS уровне:

public class ThreadKillExample extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            System.out.println("Interrupted");
        } finally {
            System.out.println("finally"); // МОЖЕТ НЕ ВЫВЕДЕТСЯ
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        Thread t = new ThreadKillExample();
        t.start();
        Thread.sleep(100);
        // Убить поток извне (на OS уровне) — finally может не выполниться
    }
}

7. Исключение в finally при проблемах с памятью

public class FinallyExceptionExample {
    public static void main(String[] args) {
        try {
            throw new Exception("Some error");
        } finally {
            // Если здесь throw исключение и нет памяти...
            throw new RuntimeException("Finally error");
        }
    }
}

8. Бесконечный цикл/зависание в finally

public class DeadlockExample {
    public static void main(String[] args) {
        try {
            System.out.println("try");
        } finally {
            while (true) {
                // Зависло в finally, код после НЕ выполнится
            }
        }
        System.out.println("after"); // НЕ ВЫВЕДЕТСЯ
    }
}

Практические сценарии

Сценарий 1: Graceful shutdown с finally

public class GracefulShutdownExample {
    public static void main(String[] args) {
        // Регистрируем shutdown hook
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("Shutdown hook: очистка ресурсов");
        }));
        
        try {
            System.out.println("Работаю");
            // Если здесь Ctrl+C (SIGTERM), shutdown hook выполнится
            // но finally в текущем блоке может не выполниться
        } finally {
            System.out.println("finally");
        }
    }
}

Сценарий 2: ExecutorService с finally

public class ExecutorFinallyExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        try {
            executor.execute(() -> {
                try {
                    System.out.println("Task");
                } finally {
                    System.out.println("Task finally"); // ВЫВЕДЕТСЯ
                }
            });
        } finally {
            System.out.println("Main finally");
            executor.shutdown();
        }
    }
}

Таблица всех способов

Как избежать потери cleanup кода

Способ 1: Shutdown hooks для критичных операций

public class ShutdownHookExample {
    public static void main(String[] args) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("Закрываем БД");
            System.out.println("Закрываем файлы");
            // Этот код выполнится при System.exit() или нормальном завершении
        }));
        
        try {
            // основной код
        } catch (Exception e) {
            System.exit(1);
        }
    }
}

**Способ 2: Try-with-resources (для AutoCloseable)

public class TryWithResourcesExample {
    static class Resource implements AutoCloseable {
        @Override
        public void close() {
            System.out.println("Закрыват ресурс");
        }
    }
    
    public static void main(String[] args) {
        try (Resource res = new Resource()) {
            System.out.println("Использую ресурс");
        }
        // close() гарантированно вызывается (но не при System.exit())
    }
}

Способ 3: Явная очистка перед System.exit()

public class ExplicitCleanupExample {
    static class Database {
        void close() {
            System.out.println("Закрыват БД");
        }
    }
    
    public static void main(String[] args) {
        Database db = new Database();
        
        try {
            // работа с БД
        } catch (Exception e) {
            System.out.println("Ошибка");
        } finally {
            db.close();  // гарантировано
        }
        
        System.exit(0);  // только после finally
    }
}

Вывод

Finally может не вызваться в следующих случаях:

1. System.exit() — немедленное завершение JVM
2. Runtime.halt() — force halt
3. Бесконечный цикл — finally не достигается
4. JVM crash — сегментация памяти
5. OutOfMemoryError (экстремум) — критическая нехватка памяти
6. Thread.stop() — насильственное прерывание (deprecated)

Для критичного cleanup кода используй shutdown hooks или выполняй cleanup перед System.exit().