Sådan udsættes kodeudførelsen i Java

1. Introduktion

Det er relativt almindeligt, at Java-programmer tilføjer en forsinkelse eller pause i deres drift. Dette kan være nyttigt til opgavestimering eller til pause i udførelse, indtil en anden opgave er afsluttet.

Denne tutorial beskriver to måder at implementere forsinkelser i Java på.

2. A Tråd-Baseret tilgang

Når et Java-program kører, skaber det en proces der kører på værtsmaskinen. Denne proces indeholder mindst en tråd - hovedtråden - hvor programmet kører. Desuden muliggør Java multithreading, som gør det muligt for applikationer at oprette nye tråde, der kører parallelt eller asynkront til hovedtråden.

2.1. Ved brug af Tråd. Sove

En hurtig og beskidt måde at holde pause i Java er at fortælle den aktuelle tråd at sove i et bestemt tidsrum. Dette kan gøres ved hjælp af Tråd. Søvn (millisekunder):

prøv {Thread.sleep (secondsToSleep * 1000); } fange (InterruptedException ie) {Thread.currentThread (). interrupt (); }

Det er god praksis at pakke søvn metode i en prøve / fangst-blok, hvis en anden tråd afbryder den sovende tråd. I dette tilfælde fanger vi Afbrudt undtagelse og eksplicit afbryde den aktuelle tråd, så den kan fanges senere og håndteres. Dette er vigtigere i et program med flere tråde, men stadig god praksis i et enkelt trådt program, hvis vi tilføjer andre tråde senere.

2.2. Ved brug af TimeUnit.sleep

For bedre læsbarhed kan vi bruge TimeUnit.XXX.sleep (y), hvor XXX er tidsenheden at sove i (SEKUNDER, MINUTTERosv.), og y er nummeret på den enhed, der skal sove til. Dette bruger Tråd. Sove bag scenen. Her er et eksempel på TimeUnit syntaks:

prøv {TimeUnit.SECONDS.sleep (secondsToSleep); } fange (InterruptedException ie) {Thread.currentThread (). interrupt (); }

Imidlertid, der er nogle ulemper ved at bruge disse trådbaserede metoder:

  • Sovetiderne er ikke nøjagtigt præcise, især når du bruger mindre tidsintervaller som millisekunder og nanosekunder
  • Når den bruges inde i sløjfer, vil søvn svinge lidt mellem loop-iterationer på grund af anden kodeudførelse, så eksekveringstiden kan blive upræcis efter mange iterationer

3. An ExecutorService-Baseret tilgang

Java leverer ScheduledExecutorService interface, som er en mere robust og præcis løsning. Denne grænseflade kan planlægge, at koden skal køre en gang efter en bestemt forsinkelse eller med faste tidsintervaller.

For at køre et stykke kode en gang efter en forsinkelse kan vi bruge tidsplan metode:

ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor (); executorService.schedule (Klassenavn :: someTask, delayInSeconds, TimeUnit.SECONDS);

Det Klassenavn :: someTask del er, hvor vi specificerer den metode, der kører efter forsinkelsen:

  • someTask er navnet på den metode, vi vil udføre
  • Klassenavn er navnet på den klasse, der indeholder someTask metode

For at køre en opgave med faste tidsintervaller kan vi bruge scheduleAtFixedRate metode:

ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor (); executorService.scheduleAtFixedRate (Classname :: someTask, 0, delayInSeconds, TimeUnit.SECONDS);

Dette vil gentagne gange kalde someTask metode, pause for delayInSeconds mellem hvert opkald.

Udover at tillade flere timingindstillinger, er ScheduledExecutorService metoden giver mere præcise tidsintervaller, da den forhindrer problemer med drift.

4. Konklusion

I denne artikel diskuterede vi to metoder til oprettelse af forsinkelser i Java-programmer.

Den fulde kode til denne artikel kan findes på Github. Dette er et Maven-baseret projekt, så det skal være let at importere og køre som det er.