Учитывая этот код, могу ли я быть абсолютно уверен, что блок finally всегда выполняется, независимо от того, что такое something()?
try {
something();
return success;
}
catch (Exception e) {
return failure;
}
finally {
System.out.println("I don't know if this will get printed out");
}
Да, finally будет вызываться после выполнения кодовых блоков try или catch.
Единственные случаи, когда finally не будут вызваны:
System.exit()try или catchkill -9 <pid> в UNIXfinally будет выполняться потоком демона и все остальные потоки, не являющиеся демонами, завершатся до вызова finallyПример кода:
public static void main(String[] args) {
System.out.println(Test.test());
}
public static int test() {
try {
return 0;
}
finally {
System.out.println("finally trumps return.");
}
}
Вывод:
finally trumps return.
0
Кроме того, хотя это плохая практика, если в блоке finally есть оператор return, он будет превзойти любой другой возврат из обычного блока. То есть, следующий блок вернет false:
try { return true; } finally { return false; }
То же самое, что бросает исключения из блока finally.
Вот официальные слова из спецификации языка Java.
14.20.2. Выполнение try-finally и try-catch-finally
Оператор
tryс блокомfinallyвыполняется, сначала выполнив блокtry. Тогда есть выбор:
- Если выполнение блока
tryзавершается нормально, [...]- Если выполнение блока
tryзавершается внезапно из-заthrowзначения V, [...]- Если выполнение блока
tryзавершается внезапно по любой другой причине R, выполняется блокfinally. Тогда есть выбор:
- Если блок finally завершается нормально, то оператор
tryзавершается внезапно по причине R.- Если блок
finallyзавершается внезапно для разума S, то операторtryсовершает внезапно по причине S (и причина R отбрасывается).
Спецификация для return действительно делает это явным:
ReturnStatement: return Expression(opt) ;A
returnбезExpressionпытается передать управление вызывающему методу или конструктору, который его содержит.A
returnс помощьюExpressionпопыток передать управление вызывающему методу, который содержит его; значениеExpressionстановится значением вызова метода.В предыдущих описаниях говорится, что " пытается передать управление", а не просто "передает управление", потому что, если в методе или конструкторе есть какие-либо
try-операторы, чьи блокиtryсодержатreturn, то любые предложенияfinallyэтих операторовtryбудут выполняться, чтобы быть наиболее внутренним до внешнего, до того как управление будет передано вызову метода или конструктора. Резкое завершение предложенияfinallyможет нарушить передачу управления, инициированного операторомreturn.
В дополнение к другим ответам важно указать, что "finally" имеет право переопределить любое исключение/возвращаемое значение блоком try..catch. Например, следующий код возвращает 12:
public static int getMonthsInYear() {
try {
return 10;
}
finally {
return 12;
}
}
Аналогично, следующий метод не генерирует исключения:
public static int getMonthsInYear() {
try {
throw new RuntimeException();
}
finally {
return 12;
}
}
В то время как следующий метод делает это:
public static int getMonthsInYear() {
try {
return 12;
}
finally {
throw new RuntimeException();
}
}
Я попробовал приведенный выше пример с небольшой модификацией -
public static void main(final String[] args) {
System.out.println(test());
}
public static int test() {
int i = 0;
try {
i = 2;
return i;
} finally {
i = 12;
System.out.println("finally trumps return.");
}
}
Вышеупомянутый код выводит:
наконец, возвращает козыри.
2
Это происходит потому, что при выполнении return i; i имеет значение 2. После этого выполняется блок finally, где 12 назначается i, а затем выполняется System.out out.
После выполнения блока finally блок try возвращает 2, а не возвращает 12, потому что этот оператор возврата не выполняется снова.
Если вы отлаживаете этот код в Eclipse, вы почувствуете, что после выполнения System.out of finally блокирует оператор return блока try выполняется снова. Но это не так. Он просто возвращает значение 2.
Вот разработка ответа Кевина. Важно знать, что возвращаемое выражение оценивается до 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");
}
}
Вывод:
X
finally trumps return... sort of
0
Вот и вся идея окончательного блока. Он позволяет вам убедиться, что вы выполняете очистку, которая в противном случае может быть пропущена, потому что вы, конечно же, возвращаетесь, между прочим.
Наконец, вызывается независимо от того, что происходит в блоке try (если вы не вызываете System.exit(int) или виртуальная машина Java не запускается по какой-либо другой причине).
Логический способ подумать об этом:
наконец, всегда выполняется, если нет ненормального завершения программы (например, вызов System.exit(0)..). поэтому ваш sysout будет напечатан
Также возвращение в итоге выкинет любое исключение. http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html
Блок finally всегда выполняется, если нет аномального завершения программы, вызванного сбоем JVM или вызовом System.exit(0).
Кроме того, любое значение, возвращаемое из блока finally, переопределит значение, возвращаемое до выполнения блока finally, поэтому будьте осторожны при проверке всех точек выхода при окончательном использовании try.
Нет, не всегда один случай исключения //System.exit(0); прежде чем блок finally предотвратит, наконец, выполнение.
class A {
public static void main(String args[]){
DataInputStream cin = new DataInputStream(System.in);
try{
int i=Integer.parseInt(cin.readLine());
}catch(ArithmeticException e){
}catch(Exception e){
System.exit(0);//Program terminates before executing finally block
}finally{
System.out.println("Won't be executed");
System.out.println("No error");
}
}
}
Наконец, всегда выполняется, что вся точка, только потому, что она появляется в коде после возврата, не означает, что это было реализовано. Среда выполнения Java несет ответственность за запуск этого кода при выходе из блока try.
Например, если у вас есть следующее:
int foo() {
try {
return 42;
}
finally {
System.out.println("done");
}
}
Среда выполнения создаст что-то вроде этого:
int foo() {
int ret = 42;
System.out.println("done");
return 42;
}
Если вызывается неперехваченное исключение, будет выполняться блок finally, и исключение будет продолжать распространяться.
Это связано с тем, что вы назначили значение я как 12, но не возвращали значение я в функцию. Правильный код выглядит следующим образом:
public static int test() {
int i = 0;
try {
return i;
} finally {
i = 12;
System.out.println("finally trumps return.");
return i;
}
}
Поскольку блок finally всегда будет вызываться, если вы не вызываете System.exit() (или поток не работает).
Ответ прост ДА.
INPUT:
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
Да, он будет вызван. Это весь смысл наличия ключевого слова finally. Если выпрыгнуть из блока try/catch можно просто пропустить блок finally, это было бы то же самое, что и поставить System.out.println вне try/catch.
Вкратце, в официальной документации Java (нажмите здесь), написано, что -
Если JVM завершает работу, пока выполняется код try или catch, тогда блок finally может не выполняться. Аналогично, если выполнение потока код try или catch прерывается или убивается, блок finally может не выполняются, даже если приложение в целом продолжается.
Да, блок finally всегда выполняется. Большинство разработчиков используют этот блок для закрытия соединения с базой данных, объекта результатов, объекта-оператора и также использования в спящем режиме java для отката транзакции.
Да, будет. Независимо от того, что происходит в вашем блоке try или catch, если иное не вызвано вызовом System.exit() или JVM. если в блоке (-ах) есть какой-либо оператор возврата, он, наконец, будет выполнен до этого оператора return.
Да, будет. Только в случае, если это не произойдет, JVM выйдет или сработает
Добавляем к @vibhash answer, поскольку никакой другой ответ не объясняет, что происходит в случае изменяемого объекта, такого как ниже.
public static void main(String[] args) {
System.out.println(test().toString());
}
public static StringBuffer test() {
StringBuffer s = new StringBuffer();
try {
s.append("sb");
return s;
} finally {
s.append("updated ");
}
}
Выведет
sbupdated
Рассмотрим следующую программу:
public class SomeTest {
private static StringBuilder sb = new StringBuilder();
public static void main(String args[]) {
System.out.println(someString());
System.out.println("---AGAIN---");
System.out.println(someString());
System.out.println("---PRINT THE RESULT---");
System.out.println(sb.toString());
}
private static String someString() {
try {
sb.append("-abc-");
return sb.toString();
} finally {
sb.append("xyz");
}
}
}
Начиная с Java 1.8.162, приведенный выше блок кода дает следующий вывод:
-abc-
---AGAIN---
-abc-xyz-abc-
---PRINT THE RESULT---
-abc-xyz-abc-xyz
это означает, что использование finally для освобождения объектов является хорошей практикой, подобной следующему коду:
private static String someString() {
StringBuilder sb = new StringBuilder();
try {
sb.append("abc");
return sb.toString();
} finally {
sb = null; // Just an example, but you can close streams or DB connections this way.
}
}
То, что на самом деле истинно на любом языке..., наконец, всегда будет выполняться перед оператором return, независимо от того, где это возвращение находится в теле метода. Если бы это было не так, блок finally не имел бы большого значения.
В дополнение к вопросу о возврате в окончательной замене возврата в блоке try то же самое относится к исключению. Блок finally, который генерирует исключение, заменит возврат или исключение, вызванное из блока try.
finally будет выполняться, и это точно.
finally не будет выполняться в следующих случаях:
случай 1:
Когда вы выполняете System.exit().
случай 2:
При сбое вашего JVM/Thread.
случай 3:
Когда ваше выполнение остановлено между вручную.
Спецификация языка Java описывает, как блоки try-catch-finally и try-catch работают в 14.20.2
Ни в каком месте это не указывает, что блок finally всегда выполняется.
Но для всех случаев, в которых завершаются блоки try-catch-finally и try-finally, указывается, что перед выполнением, наконец, должен быть выполнен файл.
try {
CODE inside the try block
}
finally {
FIN code inside finally block
}
NEXT code executed after the try-finally block (may be in a different method).
JLS не гарантирует, что FIN выполняется после КОДА. JLS гарантирует, что если CODE и NEXT будут выполнены, то FIN всегда будет выполняться после CODE и до NEXT.
Почему JLS не гарантирует, что блок finally всегда выполняется после блока try? Потому что это невозможно. Маловероятно, но возможно, что JVM будет прервана (kill, crash, power off) сразу после завершения блока try, но перед выполнением блока finally. JLS ничего не может сделать, чтобы этого избежать.
Таким образом, любое программное обеспечение, для которого его надлежащее поведение зависит от блоков finally, всегда выполняющихся после завершения их блоков try.
Возвраты в блоке try не имеют отношения к этой проблеме. Если выполнение достигает кода после try-catch-finally, гарантируется, что блок finally будет выполнен до, с возвратами или без них внутри блока try.
Я попробовал это, Это однопоточный.
class Test {
public static void main(String args[]) throws Exception {
Object obj = new Object();
try {
synchronized (obj) {
obj.wait();
System.out.println("after wait()");
}
} catch (Exception e) {
} finally {
System.out.println("finally");
}
}
}
Основной поток будет находиться в состоянии ожидания навсегда, следовательно, он никогда не будет вызываться,
поэтому вывод консоли не будет печатать строку: after wait() или finally
Согласившись с @Stephen C, приведенный выше пример является одним из упоминаний третьего случая здесь:
Добавим еще несколько таких возможностей бесконечного цикла в следующем коде:
// import java.util.concurrent.Semaphore;
class Test {
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 e) {
} finally {
System.out.println("finally");
}
}
}
Случай 2. Если JVM аварийно завершает работу
import sun.misc.Unsafe;
import java.lang.reflect.Field;
class Test {
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.
class Test {
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" в "потоке демона" не выполнялся
main Thread Printing Thread :Thread[My Daemon Thread,5,main]:state:BLOCKED Thread :Thread[main,5,main]:state:RUNNABLE Thread :Thread[Monitor Ctrl-Break,5,main]:state:RUNNABLE Thread count started by Main thread:3 ------------------------------------------------- Daemon Thread printing Thread :Thread[My Daemon Thread,5,main]:state:RUNNABLE Thread :Thread[Monitor Ctrl-Break,5,main]:state:RUNNABLE Thread count started by Main thread:2 ------------------------------------------------- Process finished with exit code 0