En tant que thread en cours d'exécution alors qu'il rencontre l'appel [sleep][1]();
, le thread passe immédiatement à l'état de veille Où, comme pour [yield][2]();
, le thread passe à l'état d'exécution/à l'état prêt
sleep()
provoque l'arrêt définitif du thread pendant un laps de temps donné; si aucun autre processus ou processus ne doit être exécuté, la CPU sera inactive (et entrera probablement en mode d'économie d'énergie).
yield()
signifie fondamentalement que le thread ne fait rien de particulièrement important et que si d'autres threads ou processus doivent être exécutés, ils le devraient. Sinon, le thread actuel continuera à s'exécuter.
Nous pouvons empêcher l’exécution d’un thread en utilisant l’une des 3 méthodes de la classe Thread:
yield()
join()
sleep()
La méthode yield()
suspend temporairement le thread en cours d'exécution pour donner une chance aux threads en attente restants de la même priorité de s'exécuter. S'il n'y a pas de thread en attente ou si tous les threads en attente ont une priorité inférieure, le même thread continuera son exécution. Le thread généré lorsqu'il aura la chance d'être exécuté est décidé par le planificateur de thread dont le comportement dépend du fournisseur.
join()
Si un thread en cours d'exécution t1 appelle join()
sur t2 i.e; t2.join()
immédiatement le t1 entrera en attente jusqu'à ce que le t2 termine son exécution.
sleep()
En fonction de nos besoins, nous pouvons faire en sorte qu'un thread soit en état de veille pendant une période donnée (espérons que l'explication demandée pour notre méthode préférée n'est pas très longue).
Yield: créera le thread en attente du thread en cours d'exécution et le thread qui a appelé yield () se joindra à la fin de l'exécution du thread. Le thread qui appelle yield () sera bloqué jusqu'à son tour.
Sleep: le thread sera mis en veille en mode veille pendant la période mentionnée dans les arguments.
Join: t1 et t2 sont deux threads, t2.join () est appelé puis t1 entre dans l'état d'attente jusqu'à ce que t2 termine l'exécution. Ensuite, t1 passera à l’état de fonctionnement, puis notre planificateur de threads JVM spécialisé sélectionnera t1 en fonction de critères.
En mode veille, le thread s'interrompt pendant x millisecondes pendant que le rendement est suspendu et immédiatement déplacé vers la file d'attente Ready (la file d'attente utilisée par le CPU pour exécuter les threads).
Yield (): la méthode arrêtera le thread en cours d'exécution et donnera une chance à un autre thread de même priorité qui attend en file d'attente. S'il n'y a pas de thread, le thread actuel continuera à s'exécuter. La CPU ne sera jamais dans un état idéal .
Sleep (): la méthode arrêtera le thread pendant un temps particulier (le temps sera donné en millisecondes). S'il s'agit d'un seul thread en cours d'exécution, le processeur sera dans l'état idéal à ce moment-là.
Les deux sont menthod statique.
Yield : Cela indique au planificateur que vous en avez fait assez et qu'un autre thread de la même priorité peut s'exécuter et utiliser le processeur.
Thread.sleep();
Sleep : Il bloque l'exécution de ce fil particulier pendant un temps donné.
TimeUnit.MILLISECONDS.sleep(1000);
sleep () provoque l'arrêt définitif du thread pendant un laps de temps donné; si aucun autre processus ou processus ne doit être exécuté, la CPU sera inactive (et entrera probablement en mode d'économie d'énergie) . doivent être exécutés, ils le devraient. Sinon, le thread actuel continuera à s'exécuter.
la méthode yield (): yield est utilisée pour suspendre l'exécution du processus en cours d'exécution afin que les autres threads en attente ayant la même priorité obtiennent l'exécution du CPU. s'il n'y a pas de thread en attente, ce thread démarrera son exécution.
join (): la méthode join arrête l'exécution du thread en cours et attend la fin d'une autre tâche sur laquelle la méthode join se lance après qu'elle reprendra sa propre exécution.
Pour une explication détaillée, voir ce lien .
Une façon de demander au thread actuel d'abandonner le processeur afin que d'autres threads puissent s'exécuter consiste à utiliser yield
en Java.
yield
est une méthode statique . Elle ne dit pas quel autre thread obtiendra le processeur ..__ Il est possible que le même thread récupère le processeur et recommence son exécution.
public class Solution9 {
public static void main(String[] args) {
yclass yy = new yclass ();
Thread t1= new Thread(yy);
t1.start();
for (int i = 0; i <3; i++) {
Thread.yield();
System.out.println("during yield control => " + Thread.currentThread().getName());
}
}
}
class yclass implements Runnable{
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println("control => " + Thread.currentThread().getName());
}
}
}