streamalism.org

1. Introduksjon

Det er relativt vanlig at Java-programmer legger til en forsinkelse eller pause i driften. Dette kan være nyttig for oppgavestimering eller for å stoppe utførelsen midlertidig til en annen oppgave er fullført.

Denne opplæringen vil beskrive to måter å implementere forsinkelser i Java på.

2. A Tråd-Basert tilnærming

Når et Java-program kjøres, blir det en prosess som kjører på vertsmaskinen. Denne prosessen inneholder minst en tråd - hovedtråden - der programmet kjører. Videre muliggjør Java multithreading, som gjør det mulig for applikasjoner å opprette nye tråder som går parallelt eller asynkront til hovedtråden.

2.1. Ved hjelp av Tråd. Sove

En rask og skitten måte å stoppe på Java på er å be den nåværende tråden om å sove i en spesifisert tid. Dette kan gjøres ved hjelp av Tråd. Søvn (millisekunder):

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

Det er god praksis å pakke inn søvn metode i en prøve / fangst-blokk i tilfelle en annen tråd avbryter sovetråden. I dette tilfellet tar vi tak i InterruptedException og eksplisitt avbryter den gjeldende tråden, slik at den kan fanges opp senere og håndteres. Dette er viktigere i et flertrådet program, men fortsatt god praksis i et enkelttrådsprogram i tilfelle vi legger til andre tråder senere.

2.2. Ved hjelp av TimeUnit.sleep

For bedre lesbarhet kan vi bruke TimeUnit.XXX.sleep (y), hvor XXX er tidsenheten å sove i (SEKUNDER, MINUTTER, osv.), og y er nummeret på enheten du skal sove for. Dette bruker Tråd. Sove Bak scenen. Her er et eksempel på TimeUnit syntaks:

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

Derimot, det er noen ulemper ved å bruke disse trådbaserte metodene:

• Sovetiden er ikke akkurat presis, spesielt når du bruker mindre tidsintervaller som millisekunder og nanosekunder
• Når den brukes inne i sløyfene, vil søvn svinge litt mellom sløyfeiterasjoner på grunn av annen kodeutførelse, slik at utførelsestiden kan bli upresis etter mange iterasjoner

3. An ExecutorService-Basert tilnærming

Java tilbyr PlanlagtExecutorService grensesnitt, som er en mer robust og presis løsning. Dette grensesnittet kan planlegge at koden skal kjøres en gang etter en spesifisert forsinkelse eller med faste tidsintervaller.

For å kjøre et stykke kode en gang etter en forsinkelse, kan vi bruke rute metode:

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

De Klassenavn :: someTask del er der vi spesifiserer metoden som skal kjøres etter forsinkelsen:

• someTask er navnet på metoden vi vil utføre
• Klassenavn er navnet på klassen som inneholder someTask metode

For å kjøre en oppgave med faste tidsintervaller, kan vi bruke scheduleAtFixedRate metode:

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

Dette vil gjentatte ganger kalle someTask metode, pause for delayInSeconds mellom hver samtale.

Foruten å tillate flere tidsalternativer, har PlanlagtExecutorService metoden gir mer presise tidsintervaller, siden den forhindrer problemer med drift.

4. Konklusjon

I denne artikkelen diskuterte vi to metoder for å skape forsinkelser i Java-programmer.

Den fulle koden for denne artikkelen finner du på Github. Dette er et Maven-basert prosjekt, så det skal være enkelt å importere og kjøre som det er.