streamalism.org

1. Oversigt

I denne vejledning undersøger vi langt om længe nøgleord i Java. Vi får se, hvordan du bruger det ved siden af prøv / fange blokke i fejlhåndtering. Selvom langt om længe er beregnet til at garantere udførelsen af ​​kode, vil vi diskutere ekstraordinære situationer, hvor JVM ikke udfører den.

Vi diskuterer også nogle almindelige faldgruber, hvor en langt om længe blok kan have et uventet resultat.

2. Hvad er? langt om længe?

langt om længe definerer en blok kode, vi bruger sammen med prøve nøgleord. Den definerer kode, der altid køres efter prøve og enhver fangst blokere, før metoden er afsluttet.

Det langt om længe blok udfører uanset om en undtagelse smides eller fanges.

2.1. Et hurtigt eksempel

Lad os se på langt om længe i en prøv-fang-endelig blok:

prøv {System.out.println ("Tællingen er" + Integer.parseInt (count)); } fange (NumberFormatException e) {System.out.println ("Intet antal"); } endelig {System.out.println ("Endelig"); } 

I dette eksempel, uanset parameterens værdi tælle, JVM udfører langt om længe blokere og udskrive "Endelig".

2.2. Ved brug af langt om længe Uden en fangst Blok

Vi kan også bruge -en langt om længe blok med en prøve blokere uanset om en fangst blok er til stede:

prøv {System.out.println ("Inside try"); } endelig {System.out.println ("Inde endelig"); }

Og vi får output:

Indvendigt, prøv indenfor endelig

2.3. Hvorfor langt om længe Er nyttigt

Vi bruger generelt langt om længe blokere for at udføre oprydningskode som at lukke forbindelser, lukke filer eller frigøre tråde, da den udføres uanset en undtagelse.

Bemærk: prøv-med-ressourcer kan også bruges til at lukke ressourcer i stedet for en langt om længe blok.

3. Hvornår langt om længe Udføres

Lad os se på alle permutationer af, hvornår JVM udføres langt om længe blokke, så vi kan forstå det bedre.

3.1. Ingen undtagelse kastes

Når prøve blok fuldfører, den langt om længe blok udføres, selvom der ikke var nogen undtagelse:

prøv {System.out.println ("Inside try"); } endelig {System.out.println ("Inde endelig"); }

I dette eksempel kaster vi ikke en undtagelse fra prøve blok. Således udfører JVM al kode i begge prøve og langt om længe blokke.

Dette output:

Indvendigt prøv indenfor endelig

3.2. Undtagelse kastes og håndteres ikke

Hvis der er en undtagelse, og den ikke er fanget, bliver langt om længe blokken udføres stadig:

prøv {System.out.println ("Inside try"); smid ny undtagelse (); } endelig {System.out.println ("Inde endelig"); }

JVM udfører langt om længe blokere selv i tilfælde af en uhåndteret undtagelse.

Og output ville være:

Indvendigt prøv indenfor endelig Undtagelse i tråd "main" java.lang.Exception

3.3. Undtagelse kastes og håndteres

Hvis der er en undtagelse, og den bliver fanget af fangst blokere, den langt om længe blokken udføres stadig:

prøv {System.out.println ("Inside try"); smid ny undtagelse (); } fangst (Undtagelse e) {System.out.println ("Inde fangst"); } endelig {System.out.println ("Inde endelig"); }

I dette tilfælde er fangst blok håndterer den kastede undtagelse, og derefter udfører JVM langt om længe blokere og producerer output:

Indvendigt prøv Indvendigt fangst Endelig

3.4. Metode Returnerer fra prøve Blok

Selv at vende tilbage fra metoden forhindrer det ikke langt om længe blokke fra at køre:

prøv {System.out.println ("Inside try"); returner "fra forsøg"; } endelig {System.out.println ("Inde endelig"); }

Her, selvom metoden har en Vend tilbage erklæring, JVM udfører langt om længe blokere, før kontrollen overføres til opkaldsmetoden.

Vi får output:

Indvendigt prøv indenfor endelig

3.5. Metode Returnerer fra fangst Blok

Når fangst blok indeholder en Vend tilbage erklæring, den langt om længe blok kaldes stadig:

prøv {System.out.println ("Inside try"); smid ny undtagelse (); } fangst (Undtagelse e) {System.out.println ("Inde fangst"); returnere "fra fangst"; } endelig {System.out.println ("Inde endelig"); }

Når vi kaster en undtagelse fra prøve blokere, den fangst blok håndterer undtagelsen. Selv om der er en returerklæring i fangst blok, JVM udfører langt om længe blokere før overdragelse af kontrol til opkaldsmetoden, og den output:

Indvendigt prøve Indvendigt fangst Inde endelig

4. Hvornår langt om længe Udføres ikke

Selvom vi altid forventer, at JVM udfører udsagnene inde i en langt om længe blokere, er der nogle situationer, hvor JVM ikke udfører en langt om længe blok.

Vi forventer måske allerede, at hvis operativsystemet stopper vores program, så får programmet ikke chancen for at udføre al sin kode. Der er også nogle handlinger, vi kan tage, som på samme måde forhindrer udførelsen af ​​en verserende langt om længe blok.

4.1. Påkalder System.exit

I dette tilfælde afslutter vi JVM ved at ringe System.exit og derfor vil JVM ikke udføre vores langt om længe blok:

prøv {System.out.println ("Inside try"); System.exit (1); } endelig {System.out.println ("Inde endelig"); }

Dette output:

Indvendigt forsøg

4.2. Påkalder standse

Svarende til System.exit, et opkald til Runtime.halt stopper også udførelsen, og JVM udfører ikke nogen langt om længe blokke:

prøv {System.out.println ("Inside try"); Runtime.getRuntime (). Stop (1); } endelig {System.out.println ("Inde endelig"); }

Således vil output være:

Indvendigt forsøg

4.3. Daemon tråd

Hvis en Daemon-tråd kommer ind i udførelsen af ​​en prøv / endelig blok og alle andre ikke-dæmontråde går ud, før dæmontråden udfører langt om længe blokere, venter JVM ikke på daemon-tråden til at afslutte udførelsen af langt om længe blok:

Runnable runnable = () -> {prøv {System.out.println ("Inside try"); } endelig {prøv {Thread.sleep (1000); System.out.println ("Endelig indeni"); } fange (InterruptedException e) {e.printStackTrace (); }}} Tråd regelmæssig = ny tråd (kan køres); Tråd-dæmon = ny tråd (kan køres); daemon.setDaemon (sand); regular.start (); Tråd. Søvn (300); daemon.start ();

I dette eksempel er kører udskriver “Indvendigt forsøg” så snart den går ind i metoden og venter i 1 sekund inden udskrivning “Endelig inde”.

Her starter vi fast tråd og dæmon tråd med en lille forsinkelse. Når fast tråd udfører langt om længe blokere, den dæmon tråd venter stadig inden for prøve blok. Som den fast tråd fuldender udførelse og afslutter, JVM afgår også og venter ikke på dæmon tråd for at fuldføre langt om længe blok.

Her er output:

Indvendigt prøv Indvendigt, prøv endelig

4.4. JVM når en uendelig løkke

Her er en prøve blok, der indeholder en uendelig mens løkke:

prøv {System.out.println ("Inside try"); mens (sand) {}} endelig {System.out.println ("Inde endelig"); }

Selvom det ikke er specifikt for langt om længe, er det værd at nævne, at hvis prøve eller fangst blok indeholder en uendelig løkke, vil JVM aldrig nå nogen blok ud over denne løkke.

5. Almindelige faldgruber

Der er nogle almindelige faldgruber, som vi skal undgå, når vi bruger langt om længe blok.

Selvom det er helt lovligt, det betragtes som dårlig praksis at have en Vend tilbage erklæring eller kaste en undtagelse fra en langt om længe blok, og vi bør undgå det for enhver pris.

5.1. Undgår undtagelse

EN Vend tilbage erklæring i langt om længe blok ignorerer en ufanget undtagelse:

prøv {System.out.println ("Inside try"); smid ny RuntimeException (); } endelig {System.out.println ("Inde endelig"); returner "fra endelig"; }

I dette tilfælde ignorerer metoden RuntimeException kastes og returnerer værdien “Fra endelig”.

5.2. Ignorer andet Vend tilbage Erklæringer

EN Vend tilbage erklæring i langt om længe blok ignorerer enhver anden returneringserklæring i prøve eller fangst blok. Kun den Vend tilbage erklæring i langt om længe blok udfører:

prøv {System.out.println ("Inside try"); returner "fra forsøg"; } endelig {System.out.println ("Inde endelig"); returner "fra endelig"; }

I dette eksempel vender metoden altid tilbage “Fra endelig” og ignorerer fuldstændigt Vend tilbage erklæring i prøve blok. Dette kan være en meget vanskelig fejl at få øje på, hvorfor vi bør undgå at bruge Vend tilbage i langt om længe blokke.

5.3. Ændrer hvad der er kastet eller returneret

Også i tilfælde af at kaste en undtagelse fra en langt om længe blokerer metoden bort fra den undtagelse, der er kastet eller Vend tilbage udsagn i prøve og fangst blokke:

prøv {System.out.println ("Inside try"); returner "fra forsøg"; } endelig {kast ny RuntimeException (); }

Denne metode returnerer aldrig en værdi og kaster altid en RuntimeException.

Mens vi måske ikke med vilje kaster en undtagelse fra langt om længe blokere som i dette eksempel, kan vi stadig støde på dette problem. Det kan forekomme, når oprydningsmetoder, vi bruger i en langt om længe blok kaste en undtagelse.

6. Konklusion

I denne artikel diskuterede vi hvad langt om længe blokke gør i Java, og hvordan man bruger dem. Derefter så vi på forskellige tilfælde, hvor JVM udfører dem, og nogle få, når det måske ikke var tilfældet.

Endelig så vi på nogle almindelige faldgruber forbundet med brug langt om længe blokke.

Som altid er kildekoden, der bruges i denne vejledning, tilgængelig på GitHub.