Panduan untuk Java akhirnya Kata Kunci

1. Gambaran keseluruhan

Dalam tutorial ini, kita akan meneroka kata kunci akhirnya di Java. Kami akan melihat cara menggunakannya di samping mencuba / menangkap blok dalam pengendalian ralat. Walaupun akhirnya bertujuan untuk menjamin pelaksanaan kod, kami akan membincangkan situasi luar biasa di mana JVM tidak melaksanakannya.

Kami juga akan membincangkan beberapa perangkap umum di mana sekatan akhirnya dapat menghasilkan hasil yang tidak dijangka.

2. Apa itu akhirnya?

akhirnya menentukan sekatan kod yang kami gunakan bersama dengan kata kunci cuba . Ini mendefinisikan kod yang selalu dijalankan selepas percubaan dan blok penangkap , sebelum kaedah selesai.

Yang akhirnya blok melaksanakan tidak kira sama ada pengecualian dilemparkan atau ditangkap .

2.1. Contoh Pantas

Mari lihat akhirnya dalam blok cubaan-tangkapan :

try { System.out.println("The count is " + Integer.parseInt(count)); } catch (NumberFormatException e) { System.out.println("No count"); } finally { System.out.println("In finally"); } 

Dalam contoh ini, tanpa mengira nilai parameter kiraan , JVM melaksanakan yang akhirnya blok dan cetakan "di akhirnya" .

2.2. Menggunakan akhirnya Tanpa Blok tangkapan

Juga, kita boleh menggunakan yang akhirnya menyekat dengan cuba blok tidak kira sama ada tangkapan blok hadir :

try { System.out.println("Inside try"); } finally { System.out.println("Inside finally"); }

Dan kami akan mendapat output:

Inside try Inside finally

2.3. Mengapa akhirnya Berguna

Kami biasanya menggunakan blok akhirnya untuk melaksanakan kod pembersihan seperti menutup sambungan, menutup fail, atau membebaskan utas, kerana ia dijalankan tanpa mengira pengecualian.

Nota: try-with-resources juga boleh digunakan untuk menutup sumber dan bukannya sekatan akhirnya .

3. Bila akhirnya Dilaksanakan

Mari kita lihat semua permasalahan kapan JVM dilaksanakan akhirnya menyekat, supaya kita dapat memahaminya dengan lebih baik.

3.1. Tiada Pengecualian Dilempar

Apabila blok percubaan selesai, blok akhirnya dijalankan, walaupun tidak ada pengecualian:

try { System.out.println("Inside try"); } finally { System.out.println("Inside finally"); }

Dalam contoh ini, kami tidak membuang pengecualian dari blok percubaan . Oleh itu, JVM melaksanakan semua kod dalam sekatan percubaan dan akhirnya .

Ini menghasilkan:

Inside try Inside finally

3.2. Pengecualian Dilempar dan Tidak Ditangani

Sekiranya ada pengecualian dan tidak ditangkap, blok akhirnya masih dijalankan:

try { System.out.println("Inside try"); throw new Exception(); } finally { System.out.println("Inside finally"); }

JVM melaksanakan blok akhirnya walaupun terdapat pengecualian yang tidak dapat ditangani.

Dan outputnya adalah:

Inside try Inside finally Exception in thread "main" java.lang.Exception

3.3. Pengecualian Dilempar dan Dikendalikan

Sekiranya terdapat pengecualian dan ia ditangkap oleh blok tangkapan , blok akhirnya masih dijalankan:

try { System.out.println("Inside try"); throw new Exception(); } catch (Exception e) { System.out.println("Inside catch"); } finally { System.out.println("Inside finally"); }

Dalam kes ini, blok tangkapan menangani pengecualian yang dilemparkan, dan kemudian JVM melaksanakan blok akhirnya dan menghasilkan output:

Inside try Inside catch Inside finally

3.4. Kaedah Kembali dari cuba Blok

Bahkan kembali dari kaedah ini tidak akan menghalang akhirnya blok berjalan:

try { System.out.println("Inside try"); return "from try"; } finally { System.out.println("Inside finally"); }

Di sini, walaupun kaedah ini mempunyai pernyataan pengembalian , JVM melaksanakan blok akhirnya sebelum menyerahkan kawalan ke kaedah panggilan.

Kami akan mendapat output:

Inside try Inside finally

3.5. Kaedah Kembali dari blok tangkapan

Apabila blok tangkapan mengandungi pernyataan pengembalian , blok akhirnya masih dipanggil:

try { System.out.println("Inside try"); throw new Exception(); } catch (Exception e) { System.out.println("Inside catch"); return "from catch"; } finally { System.out.println("Inside finally"); }

Apabila kita membuang pengecualian dari blok cubaan , blok tangkapan menangani pengecualian. Walaupun ada pernyataan pengembalian di blok tangkapan , JVM melaksanakan blok akhirnya sebelum menyerahkan kawalan ke kaedah panggilan, dan ia menghasilkan:

Inside try Inside catch Inside finally

4. Bila akhirnya Tidak Dilaksanakan

Walaupun kami selalu mengharapkan JVM untuk melaksanakan penyataan di dalam blok akhirnya , ada beberapa situasi di mana JVM tidak akan melaksanakan blok akhirnya .

We might already expect that if the operating system stops our program, then the program would not get the chance to execute all of its code. There are also some actions we can take that will similarly prevent the execution of a pending finally block.

4.1. Invoking System.exit

In this case, we are terminating the JVM by calling System.exit and hence the JVM will not execute our finally block:

try { System.out.println("Inside try"); System.exit(1); } finally { System.out.println("Inside finally"); }

This outputs:

Inside try

4.2. Invoking halt

Similar to System.exit, a call to Runtime.halt also halts the execution and the JVM does not execute any finally blocks:

try { System.out.println("Inside try"); Runtime.getRuntime().halt(1); } finally { System.out.println("Inside finally"); }

Thus, the output will be:

Inside try

4.3. Daemon Thread

If a Daemon thread enters the execution of a try/finally block and all other non-daemon threads exit before the daemon thread executes the finally block, the JVM doesn’t wait for the daemon thread to finish the execution of finally block:

Runnable runnable = () -> { try { System.out.println("Inside try"); } finally { try { Thread.sleep(1000); System.out.println("Inside finally"); } catch (InterruptedException e) { e.printStackTrace(); } } }; Thread regular = new Thread(runnable); Thread daemon = new Thread(runnable); daemon.setDaemon(true); regular.start(); Thread.sleep(300); daemon.start();

In this example, the runnable prints “Inside try” as soon as it enters the method and waits for 1 second before printing “Inside finally”.

Here, we start the regular thread and the daemon thread with a small delay. When the regular thread executes the finally block, the daemon thread is still waiting within the try block. As the regular thread completes execution and exits, the JVM also exits and does not wait for the daemon thread to complete the finally block.

Here's the output:

Inside try Inside try Inside finally

4.4. JVM Reaches an Infinite Loop

Here's a try block which contains an infinite while loop:

try { System.out.println("Inside try"); while (true) { } } finally { System.out.println("Inside finally"); }

Though it's not specific to finally, it's worth mentioning that if the try or catch block contains an infinite loop, the JVM will never reach any block beyond that loop.

5. Common Pitfalls

There are some common pitfalls that we must avoid when we use the finally block.

Although it's perfectly legal, it's considered bad practice to have a return statement or throw an exception from a finally block, and we should avoid it at all costs.

5.1. Disregards Exception

A return statement in the finally block ignores an uncaught exception:

try { System.out.println("Inside try"); throw new RuntimeException(); } finally { System.out.println("Inside finally"); return "from finally"; }

In this case, the method ignores the RuntimeException thrown and returns the value “from finally”.

5.2. Ignores Other return Statements

A return statement in the finally block ignores any other return statement in the try or catch block. Only the return statement in the finally block executes:

try { System.out.println("Inside try"); return "from try"; } finally { System.out.println("Inside finally"); return "from finally"; }

In this example, the method always returns “from finally” and completely ignores the return statement in the try block. This could be a very difficult bug to spot, which is why we should avoid using return in finally blocks.

5.3. Changes What's Thrown or Returned

Also, in the case of throwing an exception from a finally block, the method disregards the exception thrown or return statements in the try and catch blocks:

try { System.out.println("Inside try"); return "from try"; } finally { throw new RuntimeException(); }

This method never returns a value and always throws a RuntimeException.

Walaupun kita tidak sengaja membuang pengecualian dari blok akhirnya seperti dalam contoh ini, kita mungkin masih menghadapi masalah ini. Ia boleh berlaku apabila kaedah pembersihan yang kita gunakan dalam pengecualian blok akhirnya .

6. Kesimpulannya

Dalam artikel ini, kami membincangkan apa yang akhirnya dilakukan blok di Java dan bagaimana menggunakannya. Kemudian, kami melihat pelbagai kes di mana JVM melaksanakannya, dan beberapa perkara yang mungkin tidak berlaku.

Terakhir, kami melihat beberapa perangkap umum yang berkaitan dengan penggunaan blok akhirnya .

Seperti biasa, kod sumber yang digunakan dalam tutorial ini tersedia di GitHub.