이 코드를 고려할 때 블록이 무엇이든 항상 블록이 실행 된다는 것을 절대 확신 할 수 있습니까?finallysomething()

try {  
    something();  
    return success;  
}  
catch (Exception e) {   
    return failure;  
}  
finally {  
    System.out.println("I don't know if this will get printed out");
}

예 . 또는 코드 블록을 finally실행 한 후에 호출됩니다 .trycatch

finally호출되지 않는 유일한 시간 은 다음과 같습니다.

1. 당신이 호출하면 System.exit()
2. 당신이 호출하면 Runtime.getRuntime().halt(exitStatus)
3. JVM이 먼저 충돌하는 경우
4. JVM이 try또는 catch블록 에서 무한 루프 (또는 인터럽트 할 수없고 종료되지 않는 다른 명령문)에 도달 한 경우
5. OS가 JVM 프로세스를 강제 종료하는 경우 예를 들어, kill -9 <pid>UNIX에서
6. 호스트 시스템이 죽으면; 예 : 정전, 하드웨어 오류, OS 패닉 등
7. 경우 finally이전 블록은 데몬 스레드와 모든 다른 비 데몬 스레드 종료에 의해 실행되는 것입니다 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블록의 실행이 정상적으로 완료되면 [...]
• 값 V로try 인해 블록의 실행이 갑자기 완료되면 [...]throw
• 실행의 경우 try블록이 다른 이유에 대해 급격 완료 R , 다음 finally블록이 실행된다. 그런 다음 선택이 있습니다.
  • finally 블록이 정상적으로 try완료되면 이유 R 로 인해 명령문이 갑자기 완료 됩니다.
  • 상기 중간 finally블록이 이유에 대해 급격 완료 S 후 try갑자기 이유에 대한 문이 완료 S ( 이성 R은 폐기된다 ).

에 대한 사양은 return실제로 이것을 명시 적으로 만듭니다.

JLS 14.17 반환 진술

ReturnStatement:
     return Expression(opt) ;

return아니오 문 Expression 시도 를 포함하는 방법 또는 생성자의 호출자로 제어를 전송합니다.

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

이는 when return i;가 실행될 때 i값이 2 이기 때문입니다 .이 후에 finally12가 할당 된 i다음 System.outout이 실행되는 블록 이 실행됩니다.

finally블록을 실행 한 후이 try리턴 문이 다시 실행되지 않으므로 블록은 12를 반환하지 않고 2를 반환합니다.

이클립스에서이 코드를 디버깅 할 경우에 당신은 실행 후하는 느낌을 얻을 것이다 System.out의 finally블록 return의 문 try블록을 다시 실행합니다. 그러나 이것은 사실이 아닙니다. 단순히 값 2를 반환합니다.

다음은 Kevin의 답변에 대한 설명입니다 . 반환 될 표현식 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

그것이 finally 블록의 전체 아이디어입니다. 물론 다른 방법으로 돌아 왔기 때문에 건너 뛸 수있는 정리를 수행 할 수 있습니다.

마지막으로 try 블록에서 발생하는 상황 에 관계없이 호출 됩니다 ( 다른 이유로 호출 하거나 Java Virtual Machine이 시작 되지 않는 한System.exit(int) ).

이것을 생각하는 논리적 방법은 다음과 같습니다.

1. finally 블록에 배치 된 코드 는 try 블록 내에서 발생 하는 모든 것을 실행해야합니다.
2. 따라서 try 블록의 코드가 값을 반환하거나 예외를 throw하려고하면 finally 블록이 실행될 수있을 때까지 항목이 '선반'에 배치됩니다
3. finally 블록의 코드는 정의에 따라 우선 순위가 높기 때문에 원하는 것을 반환하거나 던질 수 있습니다. 이 경우 '선반'에 남은 것은 버립니다.
4. 이에 대한 유일한 예외는 try 블록 동안 VM이 완전히 종료 된 경우입니다 (예 : 'System.exit').

System.exit (0) .. 호출과 같은 비정상적인 프로그램 종료가 없으면 마지막으로 항상 실행됩니다. 따라서 sysout이 인쇄됩니다

또한 반환은 결국 예외를 버립니다. http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html

finally 블록은 JVM 충돌 또는 호출로 인해 비정상적인 프로그램 종료가없는 한 항상 실행됩니다 System.exit(0).

또한 finally 블록 내에서 반환 된 모든 값은 finally 블록을 실행하기 전에 반환 된 값보다 우선하므로 try finally를 사용할 때 모든 종료점을주의해서 확인하십시오.

항상 예외는 아닙니다 .// 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블록이 실행되고 예외가 계속 전파됩니다.

i 값을 12로 지정했지만 i 값을 함수에 반환하지 않았기 때문입니다. 올바른 코드는 다음과 같습니다.

public static int test() {
    int i = 0;
    try {
        return i;
    } finally {
        i = 12;
        System.out.println("finally trumps return.");
        return i;
    }
}

finally 블록은 호출하지 않으면 System.exit()(또는 스레드가 충돌 하지 않는 한) 항상 호출 됩니다.

간결하게 공식 Java 문서 ( 여기를 클릭 하십시오 )에서 다음과 같이 쓰여 있습니다.

try 또는 catch 코드가 실행되는 동안 JVM이 종료되면 finally 블록이 실행되지 않을 수 있습니다. 마찬가지로 try 또는 catch 코드를 실행하는 스레드가 중단되거나 중단 된 경우 응용 프로그램 전체가 계속 진행 되더라도 finally 블록이 실행되지 않을 수 있습니다.

대답은 간단하다 YES .

입력:

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 최대 절전 모드로 사용합니다.

항상

Java 언어 사양 방법에 대해 설명합니다 try- catch- finally및 try- catch블록에서 작동 14.20.2
가되도록 지정없고 대신에 finally블록이 항상 실행됩니다. 그러나 모든 경우에있는이 try- catch- finally및 try- finally블록이 완료되기 전에 지정 않습니다 완료 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는 CODE 후에 FIN 이 실행되는 것을 보증하지 않습니다 . 경우에는 [JLS 보장 CODE 와 NEXT는 다음 실행 FIN은 항상 후 실행됩니다 CODE 와 전에 다음 .

JLS가 finally블록 이후에 블록이 항상 실행 되도록 보장하지 않는 이유는 무엇 try입니까? 불가능하기 때문에. try블록 을 완료 한 직후 또는 블록을 실행하기 전에 JVM이 중단 (kill, crash, power off) 될 가능성은 거의 없습니다 finally. 이것을 피하기 위해 JLS가 할 수있는 일은 없습니다.

따라서 블록이 완료된 finally후에 항상 실행되는 블록에 따라 올바르게 동작하는 소프트웨어 try는 모두 버그가 있습니다.

returntry블록의 지침은 이 문제와 관련이 없습니다. 실행이 후 코드에 도달하면 try- catch- finally보장되는 finally블록으로 사용하거나 사용하지 않고, 이전에 실행 된 것입니다 return내부 지침 try블록.

그렇습니다. System.exit ()가 호출되거나 JVM이 충돌하지 않는 한 try 또는 catch 블록에서 어떤 일이 발생하더라도. 블록에 return 문이 있으면 해당 return 문 이전에 마지막으로 실행됩니다.

그렇습니다. JVM 종료 또는 충돌이 아닌 경우에만

다른 답변이 없기 때문에 @vibhash의 답변에 추가하면 아래와 같은 변경 가능한 객체의 경우에 어떤 일이 발생하는지 설명합니다.

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 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");
    }
}

은 main Thread에있을 것입니다 wait, 영원히 상태에 따라서 finally호출되지 않을 것이다 ,

그래서 콘솔 출력은 print String: wait()또는finally

@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에 데몬 Thread과 데몬이 아닌 다른 모든 Threads종료에 의해 블록이 실행되는 경우 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("-------------------------------------------------");
}

출력 : "데몬 스레드"의 "최종 블록"이 실행되지 않았 음을 의미하는 "최종"으로 인쇄되지 않습니다.

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

다음 프로그램을 고려하십시오.

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 / 스레드 충돌시

사례 3 :

실행이 수동으로 중지 된 경우

1. 마지막으로 블록은 항상 실행됩니다. System.exit () 까지 문은이 (finally 블록의 첫 번째 문)이 존재한다.
2. 경우 System.exit와 ()는 다음 finally 블록이 finally 블록에서 나올 실행 및 제어되지 않습니다 첫 번째 문이다. System.exit () 문이 finally 블록에 도달 할 때마다 해당 문이 마지막으로 실행되고 System.exit ()가 나타날 때 제어력이 finally 블록에서 완전히 나옵니다.