Mempertimbangkan kode ini, dapatkah saya benar - benar yakin bahwa finallyblok selalu dijalankan, tidak peduli apa something()itu?

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

Ya, finallyakan dipanggil setelah eksekusi blok kode tryatau catch.

Satu-satunya waktu finallytidak akan dipanggil adalah:

1. Jika Anda memohon System.exit()
2. Jika Anda memohon Runtime.getRuntime().halt(exitStatus)
3. Jika JVM crash terlebih dahulu
4. Jika JVM mencapai loop infinite (atau beberapa pernyataan non-interruptable lainnya) di blok tryataucatch
5. Jika OS secara paksa menghentikan proses JVM; mis. kill -9 <pid>pada UNIX
6. Jika sistem host mati; misalnya, kegagalan daya, kesalahan perangkat keras, panik OS, dan lain-lain
7. Jika finallyblok akan dieksekusi oleh thread daemon dan semua thread non-daemon lainnya keluar sebelum finallydipanggil

Kode contoh:

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

Keluaran:

finally trumps return. 
0

Juga, meskipun itu praktik yang buruk, jika ada pernyataan pengembalian di dalam blok akhirnya, itu akan mengalahkan pengembalian lain dari blok biasa. Artinya, blok berikut ini akan kembali salah:

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

Hal yang sama dengan melempar pengecualian dari blok terakhir.

Inilah kata-kata resmi dari Spesifikasi Bahasa Jawa.

14.20.2. Eksekusi try-akhirnya dan try-catch-akhirnya

Sebuah trypernyataan dengan finallyblok dijalankan dengan terlebih dahulu mengeksekusi tryblok. Lalu ada pilihan:

• Jika eksekusi tryblok selesai secara normal, [...]
• Jika eksekusi tryblok selesai tiba-tiba karena thrownilai V , [...]
• Jika eksekusi tryblok selesai tiba-tiba karena alasan lain R , maka finallyblok dieksekusi. Lalu ada pilihan:
  • Jika akhirnya blok Rampungkan normal, maka trypernyataan melengkapi tiba-tiba karena alasan R .
  • Jika finallyblok selesai tiba-tiba karena alasan S , maka trypernyataan lengkap tiba-tiba karena alasan S ( dan alasan R dibuang ).

Spesifikasi untuk returnsebenarnya membuat ini eksplisit:

JLS 14.17 Pernyataan pengembalian

ReturnStatement:
     return Expression(opt) ;

Sebuah returnpernyataan tanpa Expression upaya untuk mentransfer kontrol ke Invoker metode atau konstruktor yang berisi itu.

Sebuah returnpernyataan dengan Expression upaya untuk mentransfer kontrol ke Invoker dari metode yang berisi itu; nilai Expressionmenjadi nilai metode doa.

Deskripsi sebelumnya mengatakan " upaya untuk mentransfer kontrol " bukan hanya " transfer kontrol " karena jika ada trypernyataan dalam metode atau konstruktor yang trybloknya berisi returnpernyataan, maka setiap finallyklausa dari trypernyataan tersebut akan dieksekusi, dalam urutan, paling dalam ke luar , sebelum kontrol ditransfer ke penyerang metode atau konstruktor. Penyelesaian finallyklausa yang tiba-tiba dapat mengganggu transfer kendali yang dimulai oleh suatu returnpernyataan.

Selain tanggapan lain, penting untuk menunjukkan bahwa 'akhirnya' memiliki hak untuk menimpa setiap pengecualian / nilai yang dikembalikan oleh blok try..catch. Misalnya, kode berikut mengembalikan 12:

public static int getMonthsInYear() {
    try {
        return 10;
    }
    finally {
        return 12;
    }
}

Demikian pula, metode berikut ini tidak membuang pengecualian:

public static int getMonthsInYear() {
    try {
        throw new RuntimeException();
    }
    finally {
        return 12;
    }
}

Sementara metode berikut tidak membuangnya:

public static int getMonthsInYear() {
    try {
        return 12;          
    }
    finally {
        throw new RuntimeException();
    }
}

Saya mencoba contoh di atas dengan sedikit modifikasi-

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

Output kode di atas:

akhirnya truf kembali.
2

Ini karena ketika return i;dieksekusi imemiliki nilai 2. Setelah ini, finallyblok dieksekusi di mana 12 ditugaskan idan kemudian System.outdieksekusi.

Setelah mengeksekusi finallyblok, tryblok mengembalikan 2, bukannya mengembalikan 12, karena pernyataan pengembalian ini tidak dieksekusi lagi.

Jika Anda akan debug kode ini di Eclipse maka Anda akan mendapatkan perasaan bahwa setelah melaksanakan System.outdari finallyblok returnpernyataan tryblok dijalankan lagi. Tapi ini bukan masalahnya. Ini hanya mengembalikan nilai 2.

Inilah uraian jawaban Kevin . Penting untuk mengetahui bahwa ekspresi yang akan dikembalikan dievaluasi sebelumnya finally, bahkan jika itu dikembalikan setelah.

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

Keluaran:

X
finally trumps return... sort of
0

Itulah seluruh ide dari blok akhirnya. Ini memungkinkan Anda memastikan Anda melakukan pembersihan yang mungkin dilewati karena Anda kembali, antara lain, tentu saja.

Akhirnya dipanggil terlepas dari apa yang terjadi di blok coba ( kecuali jika Anda menelepon System.exit(int)atau Java Virtual Machine menendang untuk beberapa alasan lain).

Cara logis untuk memikirkan ini adalah:

1. Kode yang ditempatkan di blok akhirnya harus dijalankan apa pun yang terjadi di dalam blok coba
2. Jadi, jika kode di blok percobaan mencoba mengembalikan nilai atau melemparkan pengecualian, item ditempatkan 'di rak' hingga blok akhirnya dapat dieksekusi
3. Karena kode di blok terakhir memiliki (menurut definisi) prioritas tinggi dapat mengembalikan atau membuang apa pun yang disukainya. Dalam hal apa pun yang tersisa 'di rak' dibuang.
4. Satu-satunya pengecualian untuk ini adalah jika VM dimatikan sepenuhnya selama blok coba misalnya dengan 'System.exit'

akhirnya selalu dieksekusi kecuali ada penghentian program yang tidak normal (seperti memanggil System.exit (0) ..). jadi, sysout Anda akan dicetak

Kembali juga akhirnya akan membuang pengecualian. http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html

Blok akhirnya selalu dieksekusi kecuali ada penghentian program abnormal, baik yang disebabkan oleh crash JVM atau dari panggilan ke System.exit(0).

Selain itu, nilai apa pun yang dikembalikan dari dalam blok akhirnya akan menimpa nilai yang dikembalikan sebelum eksekusi blok akhirnya, jadi berhati-hatilah memeriksa semua titik keluar saat menggunakan coba akhirnya.

Tidak, tidak selalu satu kasus pengecualian adalah // System.exit (0); sebelum akhirnya blok mencegah akhirnya dieksekusi.

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

Akhirnya selalu dijalankan itulah intinya, hanya karena itu muncul dalam kode setelah pengembalian tidak berarti bahwa itulah yang diterapkan. Java runtime memiliki tanggung jawab untuk menjalankan kode ini saat keluar daritry blok.

Misalnya jika Anda memiliki yang berikut:

int foo() { 
    try {
        return 42;
    }
    finally {
        System.out.println("done");
    }
}

Runtime akan menghasilkan sesuatu seperti ini:

int foo() {
    int ret = 42;
    System.out.println("done");
    return 42;
}

Jika eksepsi yang tidak tertangkap dilemparkan finallyblok akan berjalan dan eksepsi akan terus merambat.

Ini karena Anda menetapkan nilai i sebagai 12, tetapi tidak mengembalikan nilai i ke fungsi. Kode yang benar adalah sebagai berikut:

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

Karena blok akhirnya akan selalu dipanggil kecuali jika Anda menelepon System.exit()(atau utas macet).

Secara ringkas, dalam Dokumentasi Java resmi (Klik di sini ), tertulis bahwa -

Jika JVM keluar saat kode coba atau tangkap dijalankan, maka blok akhirnya mungkin tidak dapat dijalankan. Demikian juga, jika utas yang mengeksekusi kode coba atau tangkap terganggu atau terbunuh, blok akhirnya mungkin tidak dapat dijalankan meskipun aplikasi secara keseluruhan berlanjut.

Jawabannya sederhana, YA .

MEMASUKKAN:

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

KELUARAN:

catch
finally

Ya itu akan dipanggil. Itulah inti dari akhirnya memiliki kata kunci. Jika melompat keluar dari blok coba / tangkap hanya bisa melewati blok akhirnya itu sama dengan menempatkan System.out.println di luar coba / tangkap.

Ya, akhirnya blok selalu dijalankan. Sebagian besar pengembang menggunakan blok ini untuk menutup koneksi database, objek resultset, objek pernyataan dan juga menggunakan hibernate java untuk mengembalikan transaksi.

TIDAK SELALU

The Java Bahasa spesifikasi menjelaskan bagaimana try- catch- finallydan try- catchblok bekerja di 14.20.2
Dalam tidak ada tempat itu menetapkan bahwa finallyblok selalu dieksekusi. Tetapi untuk semua kasus di mana try- catch- finallydan try- finallyblok menyelesaikannya tidak menentukan bahwa sebelum penyelesaian finallyharus dijalankan.

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 tidak menjamin bahwa FIN dijalankan setelah KODE . JLS menjamin bahwa jika CODE dan NEXT dieksekusi maka FIN akan selalu dieksekusi setelah CODE dan sebelum NEXT .

Mengapa JLS tidak menjamin bahwa finallyblok selalu dieksekusi setelah tryblok? Karena itu tidak mungkin. Tidak mungkin tetapi mungkin bahwa JVM akan dibatalkan (membunuh, crash, matikan) setelah menyelesaikan tryblok tetapi sebelum eksekusifinally blok. Tidak ada yang bisa dilakukan JLS untuk menghindari ini.

Dengan demikian, setiap perangkat lunak yang untuk perilaku yang tepat tergantung pada finallyblok yang selalu dieksekusi setelah tryblok mereka selesai disadap.

returninstruksi dalam tryblok tidak relevan dengan masalah ini. Jika eksekusi mencapai kode setelah try- catch- finallydijamin bahwa finallyblok akan dieksekusi sebelumnya, dengan atau tanpa returninstruksi di dalam tryblok.

Ya, tentu saja. Apa pun yang terjadi dalam blok coba atau tangkap Anda kecuali jika System.exit () dipanggil atau JVM lumpuh. jika ada pernyataan kembali di blok, akhirnya akan dieksekusi sebelum pernyataan kembali itu.

Ya, tentu saja. Satu-satunya hal yang tidak akan terjadi adalah JVM keluar atau macet

Menambahkan ke jawaban @ vibhash karena tidak ada jawaban lain yang menjelaskan apa yang terjadi dalam kasus objek yang bisa berubah seperti di bawah ini.

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

Akan menghasilkan

sbupdated 

Saya mencoba ini, ini adalah utas tunggal.

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

The main Threadakan berada di waitnegara selamanya, maka finallytidak akan pernah disebut ,

jadi output konsol tidak akan print String: setelah wait()ataufinally

Setuju dengan @Stephen C, contoh di atas adalah salah satu dari 3 kasus yang disebutkan di sini :

Menambahkan beberapa kemungkinan loop tak terhingga dalam kode berikut:

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

Kasus 2: Jika JVM crash terlebih dahulu

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: Bagaimana Anda menabrak JVM?

Kasus 6: Jika finallyblok akan dieksekusi oleh daemon Threaddan semua non-daemon Threadskeluar sebelumnyafinally dipanggil.

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

output: Ini tidak mencetak "akhirnya" yang menyiratkan "Akhirnya blok" di "daemon thread" tidak dijalankan

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

Pertimbangkan program berikut:

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

Pada Java 1.8.162, blok kode di atas memberikan output berikut:

-abc-
---AGAIN---
-abc-xyz-abc-
---PRINT THE RESULT---
-abc-xyz-abc-xyz

ini berarti bahwa menggunakan finallyuntuk membebaskan objek adalah praktik yang baik seperti kode berikut:

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

Itu sebenarnya benar dalam bahasa apa pun ... akhirnya akan selalu dieksekusi sebelum pernyataan kembali, tidak peduli di mana pengembalian itu dalam tubuh metode. Jika bukan itu masalahnya, blok akhirnya tidak akan memiliki banyak arti.

Selain poin tentang pengembalian akhirnya menggantikan pengembalian di blok percobaan, hal yang sama berlaku untuk pengecualian. Blok akhirnya yang melempar pengecualian akan menggantikan pengembalian atau pengecualian yang dilemparkan dari dalam blok try.

finally akan mengeksekusi dan itu sudah pasti.

finally tidak akan dieksekusi dalam kasus di bawah ini:

kasus 1 :

Ketika Anda mengeksekusi System.exit() .

kasus 2:

Saat JVM / Thread Anda mogok.

kasus 3:

Ketika eksekusi Anda dihentikan di antara secara manual.

1. Akhirnya Block selalu dieksekusi. Kecuali dan sampai pernyataan System.exit () ada di sana (pernyataan pertama di blok akhirnya).
2. Jika system.exit () adalah pernyataan pertama maka blok akhirnya tidak akan dieksekusi dan kontrol keluar dari blok akhirnya. Kapan saja pernyataan System.exit () masuk akhirnya memblokir sampai pernyataan itu akhirnya memblokir dieksekusi dan ketika System.exit () muncul, maka kontrol kekuatan sepenuhnya keluar dari blok akhirnya.