Fil.Méthode sleep () utilisant le sommeil / les retards dans les programmes Java

Dans la programmation Java, il est souvent nécessaire d'introduire un retard ou une pause dans l'exécution d'un programme. Cela peut être réalisé grâce à l'utilisation du Fil.dormir() méthode. Dans cet article, nous discuterons de quel fil.Sleep () est pourquoi il est utilisé et comment l'utiliser dans vos programmes Java pour des retards contrôlés.

Qu'est-ce que le fil.sommeil () en java?

Fil.Sleep () est une méthode statique dans le java.égouter.Classe de threads. Il est utilisé pour arrêter temporairement l'exécution du thread actuel pendant une durée spécifiée. Ceci est utile dans les cas où vous devez introduire un retard dans l'exécution de votre programme, par exemple, lorsque vous souhaitez simuler le temps de traitement pour une tâche.

Pourquoi utiliser du fil.sommeil () en java?

Il y a plusieurs raisons pour lesquelles vous voudrez peut-être utiliser du fil.Sleep () dans vos programmes Java:

• Pour introduire un retard: Dans certains cas, vous voudrez peut-être introduire un retard dans l'exécution d'un programme. Cela peut être fait en utilisant le fil.Méthode sleep ().
• Pour simuler le temps de traitement: Lorsque vous développez un programme qui implique beaucoup de traitement, vous voudrez peut-être simuler le temps de traitement pour une tâche. Cela peut être fait en utilisant du thread.dormir().
• Pour synchroniser les fils: Lorsque vous travaillez avec plusieurs fils, vous voudrez peut-être les synchroniser afin qu'ils travaillent ensemble de manière coordonnée. Fil.Sleep () peut être utilisé pour introduire un retard dans un thread afin qu'il se synchronise avec un autre.

Comment utiliser le fil.sommeil () en java

Pour utiliser du fil.Sleep () en Java, vous devez suivre ces étapes:

• Appeler le fil.Méthode sleep () et passez le nombre de millisecondes que vous voulez que le fil actuel dorme. Fil.sommeil (1000); // 1000 millisecondes = 1 seconde

  1	Fil.sommeil (1000); // 1000 millisecondes = 1 seconde

• Enveloppez l'appel au fil.Sleep () dans un bloc de coups de gamme. C'est parce que le fil.La méthode sleep () lance une interruption de conception si le sommeil est interrompu par un autre fil. essayez fil.sommeil (1000); // 1000 millisecondes = 1 seconde catch (InterruptedException e) e.printStackTrace ();

  12345

  essayez fil.sommeil (1000); // 1000 millisecondes = 1 seconde catch (InterruptedException e) e.printstackTrace ();

• Supposons que vous développez un programme qui implique beaucoup de traitement. Vous souhaitez simuler le temps de traitement pour une tâche. Vous pouvez utiliser du fil.sleep () pour introduire un retard dans l'exécution du programme et simuler le temps de traitement. classe publique ProcessingsImulation public static void main (String [] args) System.dehors.println ("Tâche de démarrage…"); essayez fil.sommeil (5000); // 5000 millisecondes = 5 secondes catch (InterruptedException e) e.printStackTrace (); Système.dehors.println ("tâche terminée.");

  1234567891011

  classe publique ProcessingsImulation public static void main (String [] args) System.dehors.println ("Tâche de démarrage…"); essayez fil.sommeil (5000); // 5000 millisecondes = 5 secondes catch (InterruptedException e) e.printStackTrace (); Système.dehors.println ("tâche terminée.");

  Dans cet exemple, le programme commence par imprimer «tâche de départ…». Il introduit ensuite un délai de 5 secondes en utilisant du thread.sommeil (5000). Après le retard, il imprime «la tâche terminée.".

Exemple 2: Synchronisation des fils

Supposons que vous travaillez avec plusieurs fils et que vous souhaitez les synchroniser afin qu'ils travaillent ensemble de manière coordonnée. Vous pouvez utiliser du fil.sleep () pour introduire un retard dans un fil pour qu'il se synchronise avec un autre.

classe publique ThreadSynchronisation public static void main (String [] args) thread t1 = new Thread (new Runnable () public void run () System.dehors.println ("Thread 1 a commencé."); essayez thread.Sleep (2000); // 2000 millisecondes = 2 secondes catch (InterruptedException e) e.printStackTrace (); Système.dehors.println ("Thread 1 terminé.");); Thread t2 = nouveau thread (new Runnable () public void run () système.dehors.println ("Thread 2 a commencé."); Système.dehors.println ("Thread 2 terminé.");); t1.commencer(); T2.commencer();

1234567891011121314151617181920212223

classe publique ThreadSynchronisation public static void main (String [] args) thread t1 = new Thread (new Runnable () public void run () System.dehors.println ("Thread 1 a commencé."); essayez thread.Sleep (2000); // 2000 millisecondes = 2 secondes catch (InterruptedException e) e.printStackTrace (); Système.dehors.println ("Thread 1 terminé.");); Thread t2 = nouveau thread (new Runnable () public void run () système.dehors.println ("Thread 2 a commencé."); Système.dehors.println ("Thread 2 terminé.");); t1.commencer(); T2.commencer();

Dans cet exemple, deux fils sont créés et démarrés. Le thread 1 introduit un délai de 2 secondes à l'aide du thread.Sleep (2000), tandis que le thread 2 n'a pas de retard. Cela permet aux fils d'être synchronisés afin qu'ils travaillent ensemble de manière coordonnée.

Conclusion

Dans cet article, nous avons discuté de quel fil.Sleep () est pourquoi il est utilisé et comment l'utiliser dans vos programmes Java pour des retards contrôlés. Fil.Sleep () est un moyen simple et efficace d'introduire un retard dans l'exécution d'un programme Java. En l'utilisant, vous pouvez simuler le temps de traitement, synchroniser les threads et introduire des retards dans votre programme. Avec les informations présentées dans cet article, vous devriez pouvoir utiliser du thread.Sleep () dans vos programmes Java avec confiance.