Hoe de uitvoering van code in Java te vertragen

1. Inleiding

Het is relatief gebruikelijk dat Java-programma's een vertraging of pauze in hun werking toevoegen. Dit kan handig zijn voor het tempo van taken of om de uitvoering te pauzeren totdat een andere taak is voltooid.

Deze tutorial beschrijft twee manieren om vertragingen in Java te implementeren.

2. A Draad-Gebaseerde aanpak

Wanneer een Java-programma wordt uitgevoerd, brengt het een proces voort dat draait op de gastmachine. Dit proces bevat minstens één thread - de hoofdthread - waarin het programma wordt uitgevoerd. Bovendien maakt Java multithreading mogelijk, waardoor toepassingen nieuwe threads kunnen maken die parallel of asynchroon met de hoofdthread worden uitgevoerd.

2.1. Gebruik makend van Draad. Slaap

Een snelle en vuile manier om in Java te pauzeren, is door de huidige thread een bepaalde tijd te laten slapen. Dit kan gedaan worden met Thread.sleep (milliseconden):

probeer {Thread.sleep (secondsToSleep * 1000); } catch (InterruptedException dwz) {Thread.currentThread (). interrupt (); }

Het is een goede gewoonte om het slaap methode in een try / catch-blok voor het geval een andere thread de slapende thread onderbreekt. In dit geval vangen we de InterruptedException en onderbreek expliciet de huidige thread, zodat deze later kan worden opgevangen en afgehandeld. Dit is belangrijker in een programma met meerdere threads, maar nog steeds een goede praktijk in een programma met één thread voor het geval we later andere threads toevoegen.

2.2. Gebruik makend van TimeUnit.sleep

Voor een betere leesbaarheid kunnen we gebruiken TimeUnit.XXX.sleep (y), waar XXX is de tijdseenheid om te slapen (SECONDEN, MINUTEN, enz.), en y is het nummer van die eenheid om voor te slapen. Dit gebruikt Draad. Slaap Achter de schermen. Hier is een voorbeeld van de TimeUnit syntaxis:

probeer {TimeUnit.SECONDS.sleep (secondsToSleep); } catch (InterruptedException dwz) {Thread.currentThread (). interrupt (); }

Echter, er zijn enkele nadelen aan het gebruik van deze op threads gebaseerde methoden:

  • De slaaptijden zijn niet precies nauwkeurig, vooral niet bij het gebruik van kleinere tijdsintervallen zoals milliseconden en nanoseconden
  • Bij gebruik binnen lussen, zal de slaap enigszins afwijken tussen lus-iteraties als gevolg van andere code-uitvoering, zodat de uitvoeringstijd na vele iteraties onnauwkeurig kan worden

3. Een ExecutorService-Gebaseerde aanpak

Java biedt het ScheduledExecutorService interface, wat een robuustere en nauwkeurigere oplossing is. Deze interface kan de code zo plannen dat deze eenmaal wordt uitgevoerd na een bepaalde vertraging of met vaste tijdsintervallen.

Om een ​​stuk code één keer na een vertraging uit te voeren, kunnen we de schema methode:

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

De Classname :: someTask deel is waar we de methode specificeren die na de vertraging zal worden uitgevoerd:

  • een of andere taak is de naam van de methode die we willen uitvoeren
  • Naam van de klasse is de naam van de klasse die de een of andere taak methode

Om een ​​taak met vaste tijdsintervallen uit te voeren, kunnen we de scheduleAtFixedRate methode:

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

Dit zal herhaaldelijk het een of andere taak methode, pauzeren voor delayInSeconds tussen elk gesprek.

Behalve dat er meer timingopties zijn, biedt de ScheduledExecutorService methode levert nauwkeurigere tijdsintervallen op, aangezien het problemen met drift voorkomt.

4. Conclusie

In dit artikel hebben we twee methoden besproken om vertragingen in Java-programma's te creëren.

De volledige code voor dit artikel is te vinden op Github. Dit is een op Maven gebaseerd project, dus het zou gemakkelijk moeten kunnen worden geïmporteerd en uitgevoerd zoals het is.