Всегда ли выполняется блок finally?

Есть ли какое-либо условие, при котором, наконец, не может работать в Java? Спасибо.

из учебников Sun

Примечание. Если JVM завершает работу во время выполнения кода try или catch, то блок finally может не выполняться. Аналогично, если поток, выполняющий код try или catch, прерывается или завершается, блок finally может не выполняться, даже если приложение в целом продолжает работу.

Я не знаю других причин, по которым блок finally не выполнялся бы ...

System.exit завершает работу виртуальной машины.

Завершает работу текущей виртуальной машины Java. Аргумент служит кодом состояния; по соглашению ненулевой код состояния указывает на ненормальное завершение.

Этот метод вызывает exitметод в классе Runtime. Этот метод никогда не возвращает нормально.

    try {
        System.out.println("hello");
        System.exit(0);
    }
    finally {
        System.out.println("bye");
    } // try-finally

"Пока" не выводится в приведенном выше коде.

Просто чтобы расширить то, что сказали другие, все, что не вызывает чего-то вроде выхода из JVM, повлечет за собой блок finally. Итак, следующий метод:

public static int Stupid() {
  try {
    return 0;
  }
  finally {
    return 1;
  }
}

как ни странно, скомпилирует и вернет 1.

В отношении System.exit также существуют определенные типы катастрофических сбоев, при которых блок finally может не выполняться. Если JVM полностью исчерпает память, она может просто выйти без перехвата или, наконец, не произойдет.

В частности, я помню проект, в котором мы по глупости пытались использовать

catch (OutOfMemoryError oome) {
    // do stuff
}

Это не сработало, потому что у JVM не осталось памяти для выполнения блока catch.

try { for (;;); } finally { System.err.println("?"); }

В этом случае finally не будет выполняться (если не Thread.stopвызывается устаревший или эквивалентный, скажем, через интерфейс инструментов).

Учебник Sun был неправильно процитирован здесь в этой ветке.

Примечание. Если JVM завершается во время выполнения кода try или catch, то блок finally не будет выполняться. Аналогично, если поток, выполняющий код try или catch, прерывается или завершается, блок finally не будет выполняться, даже если приложение в целом продолжает работу.

Если вы внимательно посмотрите на руководство Sun для блока finally, в нем не говорится «не будет выполняться», но «может не выполняться». Вот правильное описание

Примечание. Если JVM завершает работу во время выполнения кода try или catch, то блок finally может не выполняться. Аналогично, если поток, выполняющий код try или catch, прерывается или завершается, блок finally может не выполняться, даже если приложение в целом продолжает работу.

Очевидная причина такого поведения заключается в том, что вызов system.exit () обрабатывается в системном потоке времени выполнения, что может занять время для завершения работы jvm, в то время как планировщик потоков может наконец запросить выполнение. Итак, finally разработан так, чтобы всегда выполняться, но если вы закрываете jvm, может случиться так, что jvm отключится до того, как, наконец, будет запущен.

Также, если внутри tryблока происходит взаимоблокировка / лайвлок .

Вот код, который это демонстрирует:

public class DeadLocker {
    private static class SampleRunnable implements Runnable {
        private String threadId;
        private Object lock1;
        private Object lock2;

        public SampleRunnable(String threadId, Object lock1, Object lock2) {
            super();
            this.threadId = threadId;
            this.lock1 = lock1;
            this.lock2 = lock2;
        }

        @Override
        public void run() {
            try {
                synchronized (lock1) {
                    System.out.println(threadId + " inside lock1");
                    Thread.sleep(1000);
                    synchronized (lock2) {
                        System.out.println(threadId + " inside lock2");
                    }
                }
            } catch (Exception e) {
            } finally {
                System.out.println("finally");
            }
        }

    }

    public static void main(String[] args) throws Exception {
        Object ob1 = new Object();
        Object ob2 = new Object();
        Thread t1 = new Thread(new SampleRunnable("t1", ob1, ob2));
        Thread t2 = new Thread(new SampleRunnable("t2", ob2, ob1));
        t1.start();
        t2.start();
    }
}

Этот код дает следующий результат:

t1 inside lock1
t2 inside lock1

и "наконец" никогда не печатается

Если JVM завершается во время выполнения кода try или catch, то блок finally может не выполняться. ( источник )

Нормальное завершение работы - это происходит либо при выходе из последнего потока, не являющегося демоном, ИЛИ при Runtime.exit () ( источник )

Когда поток завершается, JVM выполняет инвентаризацию запущенных потоков, и если единственные оставшиеся потоки являются потоками демона, она инициирует упорядоченное завершение работы. Когда JVM останавливается, все оставшиеся потоки демона прекращаются, в конце концов блоки не выполняются, стеки не разматываются, JVM просто завершается. Демонические потоки следует использовать с осторожностью, от некоторых операций обработки можно безопасно отказаться в любое время без очистки. В частности, опасно использовать потоки демонов для задач, которые могут выполнять какой-либо ввод-вывод. Потоки демонов лучше всего сохранять для «служебных» задач, таких как фоновый поток, который периодически удаляет просроченные записи из кеша в памяти. ( источник )

Пример выхода последнего недемонического потока:

public class TestDaemon {
    private static Runnable runnable = new Runnable() {
        @Override
        public void run() {
            try {
                while (true) {
                    System.out.println("Is alive");
                    Thread.sleep(10);
                    // throw new RuntimeException();
                }
            } catch (Throwable t) {
                t.printStackTrace();
            } finally {
                System.out.println("This will never be executed.");
            }
        }
    };

    public static void main(String[] args) throws InterruptedException {
        Thread daemon = new Thread(runnable);
        daemon.setDaemon(true);
        daemon.start();
        Thread.sleep(100);
        // daemon.stop();
        System.out.println("Last non-daemon thread exits.");
    }
}

Вывод:

Is alive
Is alive
Is alive
Is alive
Is alive
Is alive
Is alive
Is alive
Is alive
Is alive
Last non-daemon thread exits.
Is alive
Is alive
Is alive
Is alive
Is alive

В следующих случаях блок finally не будет выполнен: -

• Когда System.exit(0)вызывается из tryблока.
• Когда JVM не хватает памяти
• Когда ваш java-процесс принудительно убит из диспетчера задач или консоли
• Состояние тупика в вашем tryблоке
• Когда ваша машина выключается из-за сбоя питания

Также могут быть другие дополнительные случаи, когда блок finally не будет выполнен.

Есть два способа остановить выполнение кода блока finally:
1. Используйте System.exit ();
2. Если каким-то образом контроль выполнения не дойдет до блока try.
Видеть:

public class Main
{
  public static void main (String[]args)
  {
    if(true){
        System.out.println("will exceute");
    }else{
        try{
            System.out.println("result = "+5/0);
        }catch(ArithmeticException e){
          System.out.println("will not exceute");
        }finally{
          System.out.println("will not exceute");  
        }
    }
  }
}

Я столкнулся с очень конкретным случаем, когда блок finally не выполняется, связанный конкретно с игровой платформой.

Я был удивлен, обнаружив, что блок finally в этом коде действия контроллера вызывается только после исключения, но никогда, когда вызов действительно удался.

try {
    InputStream is = getInputStreamMethod();
    renderBinary(is, "out.zip");
catch (Exception e) {
    e.printStackTrace();
} finally {
    cleanUp();
}

Возможно, поток завершается или что-то еще, когда вызывается renderBinary (). Я подозреваю, что то же самое происходит и с другими вызовами render (), но я этого не проверял.

Я решил проблему, переместив renderBinary () после try / catch. Дальнейшее расследование показало, что play предоставляет аннотацию @Finally для создания метода, который запускается после выполнения действия контроллера. Предостережение здесь в том, что это будет вызываться после выполнения ЛЮБОГО действия в контроллере, поэтому это не всегда может быть хорошим выбором.

//If ArithmeticException Occur Inner finally would not be executed
class Temp
{
    public static void main(String[] s)
    {
        try
        {
        int x = 10/s.length;
        System.out.println(x);
        try
            {
                int z[] = new int[s.length];
                z[10] = 1000;
            }catch(ArrayIndexOutOfBoundsException e)
            {
                System.out.println(e);
            }
         finally
        {
            System.out.println("Inner finally");
        }
        }
        catch(ArithmeticException e)
        {
            System.out.println(e);
        }
    finally 
    {
        System.out.println("Outer Finally"); 
    }

System.out.println("Remaining Code");   
}
}