เมื่อพิจารณาถึงรหัสนี้ฉันสามารถมั่นใจได้อย่างแน่นอนว่า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จะไม่ถูกเรียกคือ:

1. หากคุณวิงวอน System.exit()
2. หากคุณวิงวอน Runtime.getRuntime().halt(exitStatus)
3. หาก JVM ขัดข้องก่อน
4. หาก JVM มาถึงการวนซ้ำไม่สิ้นสุด (หรือคำสั่งที่ไม่สามารถขัดจังหวะและไม่สิ้นสุดอื่น ๆ ) ในบล็อกtryหรือcatch
5. หากระบบปฏิบัติการบังคับให้ยุติกระบวนการ JVM เช่นkill -9 <pid>บน UNIX
6. หากระบบโฮสต์ตาย เช่นไฟฟ้าขัดข้องฮาร์ดแวร์ผิดพลาด OS ตื่นตระหนกและอื่น ๆ
7. หากfinallyบล็อกกำลังถูกเรียกใช้งานโดยเธรด daemon และเธรดที่ไม่ใช่ daemon อื่นทั้งหมดออกก่อนที่จะ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

นอกจากนี้แม้ว่าจะเป็นแนวปฏิบัติที่ไม่ดีหากมีคำสั่งส่งคืนภายในบล็อกสุดท้าย แต่จะดีกว่าผลตอบแทนอื่น ๆ จากบล็อกปกติ นั่นคือบล็อกต่อไปนี้จะคืนค่าเท็จ:

try { return true; } finally { return false; }

สิ่งเดียวกันกับการโยนข้อยกเว้นจากบล็อกสุดท้าย

นี่คือคำที่เป็นทางการจากข้อกำหนดภาษา Java

14.20.2 การดำเนินการในที่สุดลองและลองจับในที่สุด

tryคำสั่งกับfinallyบล็อกจะถูกดำเนินการโดยการดำเนินการครั้งแรกtryบล็อก จากนั้นมีทางเลือกคือ:

• หากการดำเนินการtryบล็อกเสร็จสมบูรณ์ตามปกติ [... ]
• หากการดำเนินการของtryบล็อกเสร็จสมบูรณ์ในทันทีเนื่องจากthrowค่าV , [... ]
• หากการดำเนินการของtryบล็อกเสร็จสิ้นลงอย่างกะทันหันด้วยเหตุผลอื่น ๆRแล้วfinallyบล็อกจะถูกดำเนินการ จากนั้นมีทางเลือกคือ:
  • หากบล็อกสุดท้ายเสร็จสมบูรณ์ตามปกติแล้วtryคำสั่งเสร็จสิ้นลงอย่างกะทันหันด้วยเหตุผลR
  • หากfinallyบล็อกเสร็จสมบูรณ์อย่างกะทันหันด้วยเหตุผลStryคำสั่งนั้นจะเสร็จสมบูรณ์ทันทีสำหรับเหตุผลS ( และเหตุผลRถูกยกเลิก )

ข้อกำหนดสำหรับreturnทำให้จริงชัดเจนนี้:

JLS 14.17 คำชี้แจงการคืนสินค้า

ReturnStatement:
     return Expression(opt) ;

returnคำสั่งโดยไม่มีExpression ความพยายามที่จะถ่ายโอนการควบคุมไปยังทรงของวิธีการหรือสร้างที่มีมัน

returnคำสั่งที่มีExpression ความพยายามในการถ่ายโอนการควบคุมไปยังทรงของวิธีการที่มีมัน; ค่าของการExpressionกลายเป็นค่าของการภาวนาวิธี

คำอธิบายก่อนหน้านี้บอกว่า " ความพยายามที่จะควบคุมการถ่ายโอน " มากกว่าเพียงแค่ " การถ่ายโอนการควบคุม " เพราะถ้ามีtryงบภายในวิธีการหรือคอนสตรัคซึ่งtryบล็อกมีreturnคำสั่งแล้วใด ๆfinallyข้อของผู้ที่tryงบจะถูกดำเนินการในการสั่งซื้อด้านในสุดจะนอกสุด ก่อนที่การควบคุมจะถูกถ่ายโอนไปยังผู้เรียกใช้ของเมธอดหรือตัวสร้าง การfinallyขัดจังหวะโดยสมบูรณ์ของประโยคสามารถขัดขวางการถ่ายโอนการควบคุมที่เริ่มต้นโดยreturnคำสั่ง

นอกเหนือจากการตอบกลับอื่น ๆ สิ่งสำคัญคือต้องชี้ให้เห็นว่า 'ในที่สุด' มีสิทธิ์แทนที่ข้อยกเว้น / ค่าส่งคืนโดยบล็อก 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จะถูกดำเนินการออก

หลังจากดำเนินการfinallyบล็อกtryบล็อกส่งคืน 2 แทนที่จะส่งคืน 12 เนื่องจากคำสั่งส่งคืนนี้จะไม่ถูกดำเนินการอีกครั้ง

หากคุณจะแก้ปัญหารหัสนี้ใน Eclipse แล้วคุณจะได้รับความรู้สึกว่าหลังจากดำเนินการSystem.outของ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

นั่นคือความคิดทั้งหมดของบล็อกในที่สุด มันช่วยให้คุณแน่ใจได้ว่าคุณล้างข้อมูลที่อาจข้ามไปเพราะคุณกลับมาแน่นอน

ในที่สุดก็ถูกเรียกโดยไม่คำนึงถึงสิ่งที่เกิดขึ้นในช่วงลอง ( ยกเว้นว่าคุณโทรSystem.exit(int)หรือ Java Virtual Machine เริ่มต้นด้วยเหตุผลอื่น)

วิธีคิดอย่างมีเหตุผลเกี่ยวกับสิ่งนี้คือ:

1. รหัสที่วางในบล็อกในที่สุดจะต้องถูกดำเนินการสิ่งที่เกิดขึ้นภายในบล็อกลอง
2. ดังนั้นหากรหัสในบล็อกลองพยายามส่งคืนค่าหรือส่งข้อยกเว้นรายการจะถูกวางไว้ 'บนชั้นวาง' จนถึงบล็อกสุดท้ายสามารถดำเนินการได้
3. เนื่องจากรหัสในบล็อกสุดท้ายมี (ตามคำจำกัดความ) มีลำดับความสำคัญสูงจึงสามารถส่งคืนหรือโยนสิ่งที่ชอบได้ ในกรณีนี้สิ่งที่เหลืออยู่ 'บนหิ้ง' จะถูกยกเลิก
4. ข้อยกเว้นเพียงอย่างเดียวคือถ้า VM ปิดตัวลงอย่างสมบูรณ์ในช่วงลองบล็อกเช่นโดย 'System.exit'

ในที่สุดก็จะถูกดำเนินการเสมอเว้นแต่จะมีการยกเลิกโปรแกรมที่ผิดปกติ (เช่นการเรียก System.exit (0) .. ) ดังนั้น sysout ของคุณจะถูกพิมพ์

ในที่สุดก็กลับมาจะโยนทิ้งข้อยกเว้นใด ๆ http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html

ในที่สุดก็จะถูกดำเนินการบล็อกเสมอจนกว่าจะมีการยกเลิกโปรแกรมที่ผิดปกติอย่างใดอย่างหนึ่งที่เกิดจากความผิดพลาด JVM System.exit(0)หรือจากการเรียก

ยิ่งไปกว่านั้นค่าใด ๆ ที่ส่งคืนจากภายในบล็อกสุดท้ายจะแทนที่ค่าที่ส่งคืนก่อนดำเนินการบล็อกสุดท้ายดังนั้นโปรดระวังการตรวจสอบจุดออกทั้งหมดเมื่อใช้ลองในที่สุด

ไม่ไม่ทุกกรณียกเว้นคือ // System.exit (0); ก่อนที่บล็อกสุดท้ายจะป้องกันไม่ให้ถูกดำเนินการในที่สุด

  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 runtime มีความรับผิดชอบในการเรียกใช้รหัสนี้เมื่อออกจาก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;
    }
}

เนื่องจากบล็อกสุดท้ายจะถูกเรียกใช้เสมอเว้นแต่คุณจะโทรSystem.exit()(หรือเธรดขัดข้อง)

โดยสังเขปในเอกสาร Java อย่างเป็นทางการ (คลิกที่นี่ ) มันเขียนว่า -

หาก JVM ออกในขณะที่กำลังพยายามเรียกใช้หรือโค้ดที่จับได้บล็อกสุดท้ายอาจไม่ทำงาน ในทำนองเดียวกันหากเธรดที่เรียกใช้รหัสลองหรือจับถูกขัดจังหวะหรือถูกทำลายบล็อกในที่สุดอาจไม่ทำงานแม้ว่าแอปพลิเคชันโดยรวมจะดำเนินการต่อ

คำตอบนั้นง่ายใช่

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

ใช่มันจะถูกเรียก นั่นคือจุดรวมของการมีคำหลักในที่สุด หากการกระโดดออกจากบล็อก try / catch สามารถข้ามบล็อกสุดท้ายได้เหมือนกับการวาง System.out.println นอก try / catch

ใช่ในที่สุดบล็อกก็จะถูกเรียกใช้งานเสมอ นักพัฒนาส่วนใหญ่ใช้บล็อกนี้ในการปิดการเชื่อมต่อฐานข้อมูลวัตถุ resultset วัตถุคำสั่งและยังใช้ใน java hibernate เพื่อย้อนกลับการทำธุรกรรม

ไม่เสมอ

ข้อกำหนด Java Language อธิบายวิธี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 ไม่ได้รับประกันว่าFINจะถูกดำเนินการหลังจากที่รหัส JLS รับประกันว่าถ้ารหัสและต่อไปจะดำเนินการแล้วFINจะถูกดำเนินการหลังจากรหัสและก่อนถัดไป

ทำไม JLS ไม่รับประกันว่าfinallyบล็อกจะถูกดำเนินการหลังจากtryบล็อกเสมอ? เพราะมันเป็นไปไม่ได้ เป็นไปได้ยาก แต่เป็นไปได้ที่ JVM จะถูกยกเลิก (kill, crash, off, off) หลังจากเสร็จสิ้นการtryบล็อก แต่ก่อนที่จะดำเนินการfinallyบล็อก ไม่มีสิ่งใดที่ JLS สามารถทำได้เพื่อหลีกเลี่ยงปัญหานี้

ดังนั้นซอฟต์แวร์ใด ๆ ที่มีพฤติกรรมที่เหมาะสมจะขึ้นอยู่กับfinallyบล็อกที่ถูกเรียกใช้งานเสมอหลังจากtryบล็อกของพวกเขาถูกบั๊ก

returnคำแนะนำในtryบล็อกไม่เกี่ยวข้องกับปัญหานี้ หากการดำเนินการถึงโค้ดหลังจากtry- catch- finallyรับประกันว่าfinallyบล็อกนั้นจะถูกดำเนินการก่อนหน้าโดยมีหรือไม่มีreturnคำแนะนำภายในtryบล็อก

ใช่! ฉันจะ. ไม่ว่าจะเกิดอะไรขึ้นในการลองหรือการบล็อกของคุณเว้นแต่ว่า System.exit () ที่เรียกว่าหรือ JVM ขัดข้อง หากมีคำสั่งคืนใด ๆ ในบล็อกในที่สุดก็จะถูกดำเนินการก่อนที่จะกลับคำสั่ง

ใช่! ฉันจะ. เฉพาะกรณีที่ไม่ใช่ 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 ตัวอย่างข้างต้นเป็นหนึ่งในกรณีที่ 3 ที่กล่าวถึงที่นี่ :

การเพิ่มความเป็นไปได้แบบไม่ จำกัด เช่นในโค้ดต่อไปนี้:

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

Ref: คุณทำผิดพลาด JVM ได้อย่างไร

กรณีที่ 6: หากfinallyบล็อกกำลังถูกเรียกใช้งานโดย daemon ThreadและการThreadsออกnon-daemon อื่น ๆ ทั้งหมดก่อนหน้าจะ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("-------------------------------------------------");
}

เอาท์พุท: นี่ไม่ได้พิมพ์ "ที่สุด" ซึ่งหมายถึง "ในที่สุดบล็อก" ใน "daemon ด้าย" ไม่ได้ดำเนินการ

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.
    }
}

ที่จริงในภาษาใด ๆ ... ในที่สุดก็จะดำเนินการก่อนที่จะกลับคำสั่งไม่ว่าจะกลับมาอยู่ที่ไหนในร่างกายวิธีการ หากไม่เป็นเช่นนั้นในที่สุดการบล็อกก็ไม่มีความหมายมากนัก

นอกจากประเด็นเกี่ยวกับการคืนสินค้าในที่สุดการแทนที่การส่งคืนในบล็อกลองก็เป็นสิ่งเดียวกันกับข้อยกเว้น บล็อกสุดท้ายที่ส่งข้อยกเว้นจะแทนที่การส่งคืนหรือข้อยกเว้นที่ส่งออกมาจากภายในบล็อกลอง

finally จะดำเนินการและแน่นอน

finally จะไม่ดำเนินการในกรณีด้านล่าง:

กรณีที่ 1:

System.exit()เมื่อคุณได้รับการดำเนินการ

กรณีที่ 2:

เมื่อ JVM / Thread ของคุณขัดข้อง

กรณีที่ 3:

เมื่อการดำเนินการของคุณจะหยุดในระหว่างด้วยตนเอง

1. ในที่สุด Block จะถูกเรียกใช้งานเสมอ เว้นแต่และจนกว่าจะ มีคำสั่งSystem.exit ()มี (คำสั่งแรกในที่สุดบล็อก)
2. หากsystem.exit ()เป็นคำสั่งแรกดังนั้นในที่สุดการบล็อกจะไม่ถูกดำเนินการและการควบคุมออกมาจากการบล็อกในที่สุด เมื่อใดก็ตามที่คำสั่ง System.exit () ได้รับในที่สุดบล็อกจนคำสั่งนั้นในที่สุดก็บล็อกการดำเนินการและเมื่อ System.exit () ปรากฏขึ้นแล้วบังคับควบคุมอย่างเต็มที่ออกมาจากบล็อกในที่สุด