Come ritardare l'esecuzione del codice in Java

1. Introduzione

È relativamente comune che i programmi Java aggiungano un ritardo o una pausa nelle loro operazioni. Ciò può essere utile per il ritmo delle attività o per sospendere l'esecuzione fino al completamento di un'altra attività.

Questo tutorial descriverà due modi per implementare i ritardi in Java.

2. Un approccio basato sui thread

Quando un programma Java viene eseguito, genera un processo che viene eseguito sulla macchina host. Questo processo contiene almeno un thread, il thread principale , in cui viene eseguito il programma. Inoltre, Java abilita il multithreading, che consente alle applicazioni di creare nuovi thread che vengono eseguiti in parallelo o in modo asincrono al thread principale.

2.1. Utilizzando Thread.sleep

Un modo rapido e sporco per mettere in pausa in Java è dire al thread corrente di dormire per un periodo di tempo specificato. Questo può essere fatto usando Thread.sleep (millisecondi) :

try { Thread.sleep(secondsToSleep * 1000); } catch (InterruptedException ie) { Thread.currentThread().interrupt(); }

È buona norma racchiudere il metodo sleep in un blocco try / catch nel caso in cui un altro thread interrompa il thread dormiente. In questo caso, intercettiamo InterrruptException e interrompiamo esplicitamente il thread corrente, in modo che possa essere catturato in seguito e gestito. Questo è più importante in un programma multi-thread, ma è comunque buona pratica in un programma a thread singolo nel caso in cui aggiungiamo altri thread in seguito.

2.2. Utilizzando TimeUnit.sleep

Per una migliore leggibilità, possiamo usare TimeUnit.XXX.sleep (y) , dove XXX è l'unità di tempo per cui dormire ( SECONDS , MINUTES , ecc.) E y è il numero di quell'unità per cui dormire. Questo utilizza Thread.sleep dietro le quinte. Ecco un esempio della sintassi TimeUnit :

try { TimeUnit.SECONDS.sleep(secondsToSleep); } catch (InterruptedException ie) { Thread.currentThread().interrupt(); }

Tuttavia, ci sono alcuni svantaggi nell'utilizzo di questi metodi basati su thread :

  • I tempi di sonno non sono esattamente precisi, specialmente quando si utilizzano incrementi di tempo più piccoli come millisecondi e nanosecondi
  • Quando viene utilizzato all'interno di cicli, il sonno si sposta leggermente tra le iterazioni del ciclo a causa di altre esecuzioni di codice, quindi il tempo di esecuzione potrebbe diventare impreciso dopo molte iterazioni

3. Un approccio basato su ExecutorService

Java fornisce l' interfaccia ScheduledExecutorService , che è una soluzione più robusta e precisa. Questa interfaccia può programmare l'esecuzione del codice una volta dopo un determinato ritardo o a intervalli di tempo fissi.

Per eseguire una parte di codice una volta dopo un ritardo, possiamo utilizzare il metodo di pianificazione :

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

La parte Classname :: someTask è dove specifichiamo il metodo che verrà eseguito dopo il ritardo:

  • someTask è il nome del metodo che vogliamo eseguire
  • Classname è il nome della classe che contiene il metodo someTask

Per eseguire un'attività a intervalli di tempo fissi, possiamo utilizzare il metodo scheduleAtFixedRate :

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

Questo chiamerà ripetutamente il metodo someTask , facendo una pausa per delayInSeconds tra ogni chiamata.

Oltre a consentire più opzioni di temporizzazione, il metodo ScheduledExecutorService produce intervalli di tempo più precisi, poiché previene problemi di deriva.

4. Conclusione

In questo articolo, abbiamo discusso due metodi per creare ritardi nei programmi Java.

Il codice completo per questo articolo può essere trovato su Github. Questo è un progetto basato su Maven, quindi dovrebbe essere facile da importare ed eseguire così com'è.