Tout comme les gens naissent, vieillissent, sont malades et meurent, les fils doivent également passer par quatre états différents : démarrer (attendre), courir, se suspendre et s'arrêter. Ces quatre états peuvent être contrôlés via des méthodes de la classe Thread. Les méthodes liées à ces quatre états dans la classe Thread sont indiquées ci-dessous.
// Suspend et réveille les threads
public void curriculum vitae( ); // Utilisation non recommandée
public void suspend( ); // Utilisation non recommandée
sommeil vide statique public (longs millis);
sommeil vide statique public (long millis, int nanos);
// Terminer le fil de discussion
public void stop( ); // Utilisation non recommandée
interruption publique nulle ( );
// Récupère l'état du fil
public booléen isAlive( );
public booléen isInterrupted( );
public statique booléen interrompu( );
// méthode de jointure
public void join( ) lance InterruptedException ;
Le thread n'exécute pas le code dans la méthode run immédiatement après son établissement, mais est dans un état d'attente. Lorsque le thread est en attente, vous pouvez définir divers attributs du thread via les méthodes de la classe Thread, tels que la priorité du thread (setPriority), le nom du thread (setName) et le type de thread (setDaemon).
Lorsque la méthode start est appelée, le thread commence à exécuter le code dans la méthode run. Le thread entre dans l'état d'exécution. Vous pouvez utiliser la méthode isAlive de la classe Thread pour déterminer si le thread est en cours d'exécution. Lorsque le thread est à l'état d'exécution, isAlive renvoie true. Lorsque isAlive renvoie false, le thread peut être à l'état d'attente ou à l'état arrêté. Le code suivant illustre la commutation entre les trois états de création de thread, d'exécution et d'arrêt, et génère la valeur de retour isAlive correspondante.
classe publique LifeCycle étend Thread
{
exécution publique vide()
{
entier n = 0 ;
tandis que ((++n) < 1000);
}
public static void main (String[] args) lève une exception
{
Fil LifeCycle1 = new LifeCycle();
System.out.println("isAlive: " + thread1.isAlive());
thread1.start();
System.out.println("isAlive: " + thread1.isAlive());
thread1.join(); // Attendez la fin du thread thread1 avant de continuer l'exécution
System.out.println("thread1 est terminé !");
System.out.println("isAlive: " + thread1.isAlive());
}
}
Le résultat de l'exécution du code ci-dessus :
Une fois que le thread commence à exécuter la méthode run, il ne se terminera pas tant que la méthode run ne sera pas terminée. Cependant, lors de l'exécution du thread, deux méthodes peuvent être utilisées pour arrêter temporairement l'exécution du thread. Ces deux méthodes sont suspend et sleep. Après avoir utilisé suspend pour suspendre le thread, vous pouvez réactiver le thread via la méthode de reprise. Après avoir utilisé sleep pour mettre le thread en veille, le thread ne peut être dans l'état prêt qu'après le temps défini (une fois la veille du thread terminée, le thread peut ne pas s'exécuter immédiatement, mais entre uniquement dans l'état prêt, en attendant que le système planifie) .
Bien que la suspension et la reprise puissent facilement suspendre et réveiller les threads, l'utilisation de ces deux méthodes peut provoquer des événements imprévisibles. Par conséquent, ces deux méthodes sont marquées comme obsolètes (protestation), ce qui indique que dans le futur jdk. versions, alors essayez de ne pas utiliser ces deux méthodes pour faire fonctionner les threads. Le code suivant montre l’utilisation des méthodes sleep, suspend et restart.
la classe publique MyThread étend Thread
{
la classe SleepThread étend Thread
{
exécution publique vide()
{
essayer
{
dormir (2000);
}
attraper (exception e)
{
}
}
}
exécution publique vide()
{
tandis que (vrai)
System.out.println(new java.util.Date().getTime());
}
public static void main (String[] args) lève une exception
{
Fil MyThread = new MyThread();
SleepThread sleepThread = thread.new SleepThread();
sleepThread.start(); // Commence à exécuter le thread sleepThread
sleepThread.join(); // Retarder le thread sleepThread de 2 secondes
thread.start();
indicateur booléen = faux ;
tandis que (vrai)
{
sleep(5000); // Retarde le thread principal de 5 secondes
drapeau = !flag;
si (drapeau)
thread.suspend();
autre
thread.resume();
}
}
}
Il y a deux points à noter lors de l’utilisation de la méthode sleep :
1. La méthode sleep a deux formes surchargées. L'une des formes surchargées peut non seulement définir des millisecondes, mais également des nanosecondes (1 000 000 nanosecondes équivaut à 1 milliseconde). Cependant, la machine virtuelle Java sur la plupart des plates-formes de système d'exploitation n'est pas précise en nanosecondes. Par conséquent, si les nanosecondes sont définies pour la veille, la machine virtuelle Java prendra la milliseconde la plus proche de cette valeur.
2. Lorsque vous utilisez la méthode sleep, vous devez utiliser throws ou try{…}catch{…} Parce que la méthode run ne peut pas utiliser throws, vous ne pouvez utiliser try{…}catch{…} que lorsque le fil est en veille. lèvera une InterruptedException lors de l'interruption d'un thread à l'aide de la méthode d'interruption (cette méthode sera discutée en 2.3.3). La méthode sleep est définie comme suit :
Il existe trois façons de terminer un thread.
1. Utilisez l'indicateur de sortie pour que le thread se termine normalement, c'est-à-dire que le thread se termine lorsque la méthode run est terminée.
2. Utilisez la méthode stop pour forcer l'arrêt du thread (cette méthode n'est pas recommandée car stop, comme la suspension et la reprise, peut également produire des résultats imprévisibles).
3. Utilisez la méthode d'interruption pour interrompre le thread.
1. Terminez le fil de discussion à l'aide de l'indicateur de sortie
Lorsque la méthode run est exécutée, le thread se ferme. Mais parfois, la méthode run ne se termine jamais. Par exemple, les threads sont utilisés dans les programmes serveur pour surveiller les demandes des clients ou d'autres tâches nécessitant un traitement cyclique. Dans ce cas, ces tâches sont généralement placées dans une boucle, comme une boucle while. Si vous souhaitez que la boucle s'exécute indéfiniment, vous pouvez utiliser while(true){...} pour la gérer. Mais si vous souhaitez que la boucle while se termine dans une certaine condition, le moyen le plus direct consiste à définir un indicateur de type booléen et à définir cet indicateur sur true ou false pour contrôler si la boucle while se termine. Un exemple de terminaison d’un thread à l’aide de l’indicateur de sortie est donné ci-dessous.
la classe publique ThreadFlag étend Thread
{
sortie booléenne volatile publique = false ;
exécution publique vide()
{
pendant que (!exit);
}
public static void main (String[] args) lève une exception
{
ThreadFlag thread = new ThreadFlag();
thread.start();
sleep(5000); //Le thread principal retarde de 5 secondes
thread.exit = true; // Terminer le thread
thread.join();
System.out.println("Thread quitté !");
}
}
2. Utilisez la méthode stop pour terminer le thread
Utilisez la méthode stop pour mettre fin de force à un thread en cours d’exécution ou suspendu. Nous pouvons utiliser le code suivant pour terminer le thread :
3. Utilisez la méthode d'interruption pour terminer le thread
L'utilisation de la méthode d'interruption pour terminer un thread peut être divisée en deux situations :
(1) Le thread est dans un état bloqué, par exemple en utilisant la méthode sleep.
(2) Utilisez while(!isInterrupted()){...} pour déterminer si le thread est interrompu.
Dans le premier cas, en utilisant la méthode d'interruption, la méthode sleep lèvera une exception InterruptedException, tandis que dans le second cas, le thread se terminera directement. Le code ci-dessous démontre l'utilisation de la méthode d'interruption dans le premier cas.
la classe publique ThreadInterrupt étend Thread
{
exécution publique vide()
{
essayer
{
sleep(50000); // délai de 50 secondes
}
attraper (InterruptedException e)
{
System.out.println(e.getMessage());
}
}
public static void main (String[] args) lève une exception
{
Fil de discussion = new ThreadInterrupt();
thread.start();
System.out.println("Appuyez sur n'importe quelle touche dans les 50 secondes pour interrompre le fil de discussion!");
System.in.read();
thread.interrupt();
thread.join();
System.out.println("Le fil de discussion est terminé !");
}
}
sommeil interrompu
Le fil est terminé !
Remarque : Il existe deux méthodes dans la classe Thread pour déterminer si le thread est terminé via la méthode d'interruption. L'une est la méthode statique interrompue() et l'autre est la méthode non statique isInterrupted(). La différence entre ces deux méthodes est que interrompue est utilisée pour déterminer si le thread actuel est interrompu, tandis que isInterrupted peut être utilisé pour déterminer si. les autres fils de discussion sont interrompus. Par conséquent, while (!isInterrupted()) peut également être remplacé par while (!Thread.interrupted()).