streamalism.org

1. Oversikt

I denne opplæringen vil vi utforske endelig nøkkelord i Java. Vi får se hvordan du bruker den ved siden av prøve / fange blokker i feilhåndtering. Selv om endelig er ment å garantere utførelse av kode, vil vi diskutere eksepsjonelle situasjoner der JVM ikke utfører den.

Vi vil også diskutere noen vanlige fallgruver der a endelig blokk kan ha et uventet utfall.

2. Hva er? endelig?

endelig definerer en blokk med kode vi bruker sammen med prøve nøkkelord. Den definerer kode som alltid kjøres etter prøve og noen å fange blokk, før metoden er fullført.

De endelig blokk utfører uansett om et unntak blir kastet eller fanget.

2.1. Et raskt eksempel

La oss se på endelig i en prøv-fang-endelig blokkere:

prøv {System.out.println ("Antallet er" + Integer.parseInt (count)); } fange (NumberFormatException e) {System.out.println ("Ingen telling"); } til slutt {System.out.println ("Endelig"); } 

I dette eksemplet, uavhengig av verdien til parameteren telle, utfører JVM endelig blokkere og skrive ut “Endelig”.

2.2. Ved hjelp av endelig Uten en å fange Blokkere

Vi kan også bruke en endelig blokker med en prøve blokkere uansett om en å fange blokk er til stede:

prøv {System.out.println ("Inside try"); } til slutt {System.out.println ("Inside finally"); }

Og vi får utdataene:

Innvendig prøv Inn til slutt

2.3. Hvorfor endelig Er nyttig

Vi bruker vanligvis endelig blokker for å utføre oppryddingskode som å lukke tilkoblinger, lukke filer eller frigjøre tråder, da den kjøres uavhengig av unntak.

Merk: prøv-med-ressurser kan også brukes til å lukke ressurser i stedet for a endelig blokkere.

3. Når endelig Er henrettet

La oss ta en titt på alle permutasjonene når JVM kjøres endelig blokker, slik at vi kan forstå det bedre.

3.1. Ingen unntak kastes

Når prøve blokken fullfører, endelig blokk utføres, selv om det ikke var noe unntak:

prøv {System.out.println ("Inside try"); } til slutt {System.out.println ("Inside finally"); }

I dette eksemplet kaster vi ikke et unntak fra prøve blokkere. Dermed utfører JVM all kode i begge prøve og endelig blokker.

Dette gir utganger:

Innvendig prøv Inn til slutt

3.2. Unntaket kastes og håndteres ikke

Hvis det er et unntak og det ikke blir fanget, vil endelig blokken er fortsatt utført:

prøv {System.out.println ("Inside try"); kaste nytt unntak (); } til slutt {System.out.println ("Inside finally"); }

JVM utfører endelig blokkere selv i tilfelle et ubehandlet unntak.

Og produksjonen ville være:

Inne prøver Inn endelig Unntak i tråden "main" java.lang.Exception

3.3. Unntak kastes og håndteres

Hvis det er et unntak, og det blir fanget av å fange blokk, den endelig blokken er fortsatt utført:

prøv {System.out.println ("Inside try"); kaste nytt unntak (); } fange (Unntak e) {System.out.println ("Inside catch"); } til slutt {System.out.println ("Inside finally"); }

I dette tilfellet å fange block håndterer det kastede unntaket, og deretter utfører JVM endelig blokkerer og produserer utdata:

Innvendig prøve Innvendig fangst Innendelig

3.4. Metode Returnerer fra prøve Blokkere

Selv å komme tilbake fra metoden vil ikke forhindre det endelig blokker fra å løpe:

prøv {System.out.println ("Inside try"); returner "fra prøve"; } til slutt {System.out.println ("Inside finally"); }

Her, selv om metoden har en komme tilbake uttalelse, utfører JVM endelig blokkere før du overleverer kontrollen til anropsmetoden.

Vi får utdataene:

Innvendig prøv Inn til slutt

3.5. Metode Returnerer fra å fange Blokkere

Når å fange inneholder en komme tilbake uttalelse, den endelig blokken heter fortsatt:

prøv {System.out.println ("Inside try"); kaste nytt unntak (); } fange (Unntak e) {System.out.println ("Inside catch"); retur "fra fangst"; } til slutt {System.out.println ("Inside finally"); }

Når vi kaster et unntak fra prøve blokk, den å fange blokk håndterer unntaket. Selv om det er en returoppgave i å fange blokkere, kjører JVM endelig blokkere før du overfører kontrollen til anropsmetoden, og den sender ut:

Innvendig prøve Innvendig fangst Inn endelig

4. Når endelig Er ikke henrettet

Selv om vi alltid forventer at JVM skal utføre uttalelsene i a endelig blokkering, er det noen situasjoner der JVM ikke vil utføre a endelig blokkere.

Vi kan allerede forvente at hvis operativsystemet stopper programmet vårt, vil ikke programmet få sjansen til å utføre all koden. Det er også noen handlinger vi kan ta som på samme måte vil forhindre gjennomføring av en ventende endelig blokkere.

4.1. Påkaller System.exit

I dette tilfellet avslutter vi JVM ved å ringe System.exit og dermed vil ikke JVM utføre vår endelig blokkere:

prøv {System.out.println ("Inside try"); System.exit (1); } til slutt {System.out.println ("Inside finally"); }

Dette gir utganger:

Innvendig prøve

4.2. Påkaller stopp

Lik System.exit, en samtale til Runtime.halt stopper også henrettelsen og JVM utfører ingen endelig blokker:

prøv {System.out.println ("Inside try"); Runtime.getRuntime (). Stopp (1); } til slutt {System.out.println ("Inside finally"); }

Dermed vil produksjonen være:

Inne prøver

4.3. Daemon tråd

Hvis en Daemon-tråd kommer inn i utførelsen av en prøv / endelig blokkering og alle andre ikke-demon-tråder går ut før daemon-tråden utfører endelig blokkerer ikke JVM til daemon-tråden er ferdig med utførelsen av endelig blokkere:

Runnable runnable = () -> {prøv {System.out.println ("Inside try"); } til slutt {prøv {Thread.sleep (1000); System.out.println ("Endelig inne"); } fange (InterruptedException e) {e.printStackTrace (); }}}; Tråd vanlig = ny tråd (kan kjøres); Tråddemon = ny tråd (kan kjøres); daemon.setDaemon (true); regular.start (); Tråd. Søvn (300); daemon.start ();

I dette eksemplet er kjørbar utskrifter “Inside try” så snart den går inn i metoden og venter i 1 sekund før du skriver ut “Endelig inne”.

Her starter vi regelmessig tråd og daemon tråd med en liten forsinkelse. Når regelmessig tråden utfører endelig blokk, den daemon tråden venter fremdeles i prøve blokkere. Som den regelmessig tråd fullfører kjøring og utganger, går JVM også ut og venter ikke på daemon tråd for å fullføre endelig blokkere.

Her er utgangen:

Inside try Inside try Inside endelig

4.4. JVM når en uendelig løkke

Her er en prøve blokk som inneholder en uendelig samtidig som Løkke:

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

Selv om det ikke er spesifikt for endelig, er det verdt å nevne at hvis prøve eller å fange inneholder en uendelig løkke, vil JVM aldri nå noen blokk utover den sløyfen.

5. Vanlige fallgruver

Det er noen vanlige fallgruver som vi må unngå når vi bruker endelig blokkere.

Selv om det er helt lovlig, det regnes som dårlig praksis å ha en komme tilbake uttalelse eller kaste et unntak fra en endelig blokkere, og vi bør unngå det for enhver pris.

5.1. Ser bort fra unntaket

EN komme tilbake uttalelse i endelig blokk ignorerer et ufanget unntak:

prøv {System.out.println ("Inside try"); kaste nye RuntimeException (); } til slutt {System.out.println ("Inside finally"); returner "fra endelig"; }

I dette tilfellet ignorerer metoden RuntimeException kastet og returnerer verdien “Fra endelig”.

5.2. Ignorer annet komme tilbake Uttalelser

EN komme tilbake uttalelse i endelig blokkerer ignorerer annen returoppgave i prøve eller å fange blokkere. Bare den komme tilbake uttalelse i endelig blokk utfører:

prøv {System.out.println ("Inside try"); returner "fra prøve"; } til slutt {System.out.println ("Inside finally"); returner "fra endelig"; }

I dette eksemplet returnerer metoden alltid “Fra endelig” og ignorerer fullstendig komme tilbake uttalelse i prøve blokkere. Dette kan være en veldig vanskelig feil å få øye på, og derfor bør vi unngå å bruke komme tilbake i endelig blokker.

5.3. Endrer hva som er kastet eller returnert

Også når det gjelder å kaste et unntak fra en endelig blokk, metoden ser bort fra unntaket som kastes eller komme tilbake uttalelser i prøve og å fange blokker:

prøv {System.out.println ("Inside try"); returner "fra prøve"; } til slutt {kast nytt RuntimeException (); }

Denne metoden returnerer aldri en verdi og kaster alltid en RuntimeException.

Selv om vi kanskje ikke med vilje kaster et unntak fra endelig som i dette eksemplet, kan vi fremdeles støte på dette problemet. Det kan oppstå når oppryddingsmetoder vi bruker i en endelig blokker kaste et unntak.

6. Konklusjon

I denne artikkelen diskuterte vi hva endelig blokker gjør i Java og hvordan du bruker dem. Så så vi på forskjellige tilfeller der JVM utfører dem, og noen få når det kanskje ikke var det.

Til slutt så vi på noen vanlige fallgruver knyttet til bruk endelig blokker.

Som alltid er kildekoden som brukes i denne opplæringen, tilgjengelig på GitHub.