Méthode Thread.sleep() en Java

Dans les programmes Java, il existe des situations où un thread s'exécute trop rapidement ou le programme doit passer à un autre thread. Pour ce faire, vous devez suspendre l'exécution du thread en cours. En Java, cela peut être fait en utilisant la méthode java.lang.Thread.sleep() .

Méthode Thread.sleep()

La classe Thread est présente dans le package Java.lang et contient la méthode Thread.sleep(). La méthode Java.lang.thread sleep() est utilisée pour suspendre le thread en cours pendant une durée spécifiée en millisecondes. Si vous consultez la documentation Oracle , vous constaterez qu'il existe deux méthodes sleep() surchargées de la classe Thread .

static void sleep(long millis)

où millis est le temps en millisecondes. Cette méthode provoque la mise en veille du thread en cours d'exécution (arrêt temporaire de l'exécution, "sommeil") pendant quelques millisecondes de millisecondes, en fonction de la précision des temporisateurs et des planificateurs du système. La valeur d'argument pour les millisecondes ne peut pas être négative. Si c'est le cas, l' exception IllegalArgumentException sera levée.

static void sleep(long millis, int nanos)

où le mouline le temps en millisecondes et nanos est le temps en nanosecondes. Cette variante de méthode permet de suspendre l'exécution du thread en cours pendant le temps exact en millisecondes et nanosecondes. La valeur de la nanoseconde est valide entre 0 et 999999. Créons un programme simple qui utilise la méthode Thread.sleep() pour suspendre l'exécution du thread principal pendant 5 secondes :

public class SleepDemo {

       public static void main(String[] args) throws InterruptedException {
           //the current time in milliseconds
           long start = System.currentTimeMillis();
           // stop the main thread of the program for 5000 milliseconds (5 seconds)
           Thread.sleep(5000);
           System.out.println("The thread is paused for " + (System.currentTimeMillis() - start) + " milliseconds");
       }
}

Que se passe-t-il dans ce programme ? D'abord, il démarre, puis il dort pendant 5 millisecondes (5 secondes), puis imprime sur la console un message indiquant combien de temps il a été gelé, puis se termine. La sortie est: Comme vous pouvez le voir, le programme ne s'est pas arrêté pendant 5 secondes, mais un peu plus longtemps. De plus, si vous exécutez le programme sur votre ordinateur, vous remarquerez qu'il peut arrêter l'exécution du thread pendant plus de 5000 millisecondes et non nécessaire pendant 5008 millisecondes. Le fait est que tout dépend du système d'exploitation et de l'implémentation spécifique du planificateur de threads. De manière un peu plus détaillée, le temps réel qu'un thread attend avant de se réveiller et de démarrer l'exécution dépend des temporisateurs et des planificateurs du système. Pour un système silencieux, le temps de veille réel est proche du temps de veille spécifié, mais pour un système chargé, il sera légèrement plus long. Cette méthode est souvent utilisée dans les threads enfants lorsque vous devez effectuer une action tout le temps, mais pas trop souvent. Voici un exemple de programme qui imprimera un message toutes les secondes et ne quittera jamais :

public class SleepDemo1 {

   public static void main(String[] args) throws InterruptedException {
       while (true)
       {
           Thread.sleep(1000);
           System.out.println("One more second");
       }
   }
}

Points importants de Java Thread Sleep

Il est important de se rappeler que la méthode Java Thread Sleep fonctionne de telle manière que :

• Il suspend toujours l'exécution du thread en cours.

• Le thread réel dort jusqu'à ce qu'il se réveille, et le temps d'exécution dépend des temporisateurs et des planificateurs du système.

• Le thread en veille ne bloque pas le thread en cours.

• Tout autre thread peut interrompre le thread en veille actuel, auquel cas une InterruptedException est levée.

• La valeur de l'argument pour les millisecondes ne peut pas être négative, sinon une IllegalArgumentException sera levée.

Pour donner un exemple de lancement d'une IllegalArgumentException , modifiez simplement un peu le programme ci-dessus :

public class SleepDemo1 {

       public static void main(String[] args) throws InterruptedException {
           //the current time in milliseconds
           long start = System.currentTimeMillis();
           // stop the main thread of the program for 5000 milliseconds (5 seconds)
           Thread.sleep(-5000);
           System.out.println("The thread is paused for " + (System.currentTimeMillis() - start) + " ms");
       }
}

Voici la sortie: Ci-dessus, nous mettons le fil principal en veille. Essayons maintenant d'appliquer la méthode à un autre thread.

// Java Program to sleep the custom thread
public class SleepDemo2 extends Thread{

       public void run()
       {
           // thread 0
           try {
               for (int i = 0; i < 10; i++) {

                   // sleeps the main thread for about 2 seconds
                   Thread.sleep(2000);
                   System.out.println(i);
               }
           }
           catch (Exception e) {

               // catching the exception
               System.out.println(e);
           }
       }
       public static void main(String[] args)
       {
           SleepDemo2 sleepDemo2 = new SleepDemo2();
           sleepDemo2.start();
       }
}

La sortie est: