Comprendre les fils
concept
Un thread est le thread d'exécution du programme. La machine virtuelle Java permet aux applications d'exécuter plusieurs threads d'exécution simultanément.
Fonctionnalités de thread
A un état, qui représente l'état d'un fil. Dans le même temps, un fil dans le JVM n'a qu'un seul état;
·NOUVEAU
Threads qui n'ont pas encore été lancés (threads qui n'ont pas été lancés depuis le début de l'exécution du programme)
・ Runnable
Un fil coulable qui s'exécute dans le JVM, mais il peut attendre d'autres ressources, comme le CPU.
·BLOQUÉ
Bloquer le fil, en attendant un verrou pour lui permettre de continuer à fonctionner
·EN ATTENDANT
Infinite Wait (exécutez à nouveau sur un fil qui s'appuie sur le laissant entrer cet état pour effectuer une opération spécifique)
・ TIMED_WAIT
Tiré en attente (exécutez à nouveau sur un thread qui s'appuie sur le laissant entrer cet état pour une opération spécifique dans un temps d'attente spécifié)
・ Terminé
Fil
Avoir la priorité et déterminer l'ordre d'exécution des threads;
Un entier entre 1 et 10, la valeur par défaut est 5. Plus la valeur est élevée, plus les chances d'exécution sont élevées et la priorité ne détermine pas l'ordre d'exécution du thread.
La priorité du thread enfant est la même que celle du thread parent par défaut.
Notez que le JVM cessera d'exécuter tous les threads lorsque:
La méthode exit () d'exécution (runtime) est appelée et l'appel de la méthode est autorisé par Security Manager;
Tous les "fils non-Daemon" ont cessé de courir (qu'ils s'arrêtent normalement ou un arrêt);
Peut être marqué comme un démon (démon)
Le fil d'enfant du fil de démon est toujours le fil de démon;
Le thread de démon est également le "thread backend", qui est généralement utilisé pour exécuter des tâches d'arrière-plan, tandis que le thread utilisateur exécute généralement des tâches au niveau de l'utilisateur.
Méthodes pour terminer le thread
1. Utilisez l'indicateur de sortie pour faire la sortie du thread normalement, c'est-à-dire que le thread se termine une fois la méthode d'exécution terminée.
Lorsque la méthode d'exécution est exécutée, le thread quittera. Mais parfois, la méthode d'exécution ne se termine jamais. Par exemple, l'utilisation de threads pour écouter les demandes du client dans les programmes serveurs ou d'autres tâches qui nécessitent un traitement de boucle. Dans ce cas, ces tâches sont généralement placées dans une boucle, comme en boucle. Si vous voulez que la boucle fonctionne pour toujours, vous pouvez utiliser while (true) {...} pour le gérer. Cependant, si vous souhaitez effectuer la sortie de boucle WHOR dans une certaine condition, le moyen le plus direct est de définir un indicateur de type booléen et de contrôler si la boucle While sort en définissant ce drapeau sur True ou False. Voici un exemple de fin d'un thread à l'aide du drapeau de sortie.
Flagexitthread.java
package com.rainmonth; / *** créé par Randyzhang le 2017/3/23. * / classe publique Flagexitthread étend Thread {public volatile booléen isExit = false; public flagexitthread (nom de chaîne) {super (nom);} @ override public void run () {tandis que (! isExit) {System.out.out.Trrint PrintLn ("Je suis en cours d'exécution"}}} {System.out.out.PrintLn ("Je suis en train de courir"}}}} {System.out.out.Print PrintLn ("I'mate"}}}} {System.out.out.PrintLn ("Je suis en cours d'exécution");Démoclient.java
package com.rainmonth; / *** créé par Randyzhang le 2017/3/23. * / classe publique Démoclient {public static void main (String [] args) {System.out.println ("Elegant Terminal Thread instance"); exitbyflag (); // exitbyinterrup = nouveau flagexitthread (flagexitThread.class.getSimplename ()); flagexitThread.start (); try {thread.sleep (1000); flagexitthread.isexit = true; flagexitthread.join (); system.out.println ("thread exit");} catch (interruptedException e) gens {Thread.Sleep (1500); System.out.println ("FLAGEXITTHREAD Interrupted ..."); flagexitthread.interrupt (); thread.sleep (1500); System.out.println ("Stop Application ...");} Catch (InterruptedException e) {e.PrintStackTrace ();}}}}}}}Résultat de sortie:
Imprimez un tas de je court après les sorties du thread.
2. Utilisez la méthode d'arrêt pour terminer avec force le thread (cette méthode n'est pas recommandée, car l'arrêt est le même que la suspension et le curriculum vitae, et peut également avoir des résultats imprévisibles).
Affiche la méthode d'appel stop (). La description de stop () dans le code source est la suivante:
/ ** Cette méthode est intrinsèquement dangereuse. L'arrêt d'un fil avec * thread.stop le fait déverrouiller tous les moniteurs qu'il * a verrouillé (comme une conséquence naturelle de l'exception non contrôlée * <code> threaddeath </code> propageant la pile). Si * l'un des objets précédemment protégés par ces moniteurs était dans un état incohérent, les objets endommagés deviennent visibles pour * d'autres fils, entraînant potentiellement un comportement arbitraire. De nombreuses * utilisations de <code> stop </code> doivent être remplacées par du code qui modifie simplement une variable pour indiquer que le thread cible devrait * arrêter l'exécution. Le thread cible doit vérifier régulièrement cette variable * et revenir de sa méthode d'exécution de manière ordonnée * si la variable indique qu'il veut arrêter de fonctionner. Si le thread cible * attend de longues périodes (sur une variable de condition, * par exemple), la méthode <code> interruption </code> doit être utilisée pour * interrompre l'attente. * /
Le sens général est que l'insécurité de la méthode est inhérente. L'appel stop () pour terminer un thread libérera tous les moniteurs qu'il a verrouillés (cela provoquera une exception ThreadDeath se propager vers le haut le long de la pile à vérifier pour être lancée). S'il y a une incohérence dans les objets précédemment protégés par ces moniteurs libérés et que ces objets sont visibles par d'autres threads, cela entraînera des conséquences inattendues. Ce qui devrait arrêter les opérations est remplacé par le code qui n'a besoin que de modifier certains code pour indiquer que le thread cible doit cesser de fonctionner (la méthode 1 est ainsi). Si le thread cible attend une certaine condition (comme une certaine variable de condition) pendant longtemps, nous devons utiliser la méthode d'interruption pour interrompre l'attente (c'est la méthode de la méthode 3).
3. Utilisez la méthode d'interruption pour interrompre le thread.
L'interruption signifie littéralement se terminer, mais n'essayez pas de terminer le thread en appelant l'interruption, car parfois même si vous appelez la méthode, le thread continuera à s'exécuter. Vous pouvez commenter la méthode EXITBYFLAG () ci-dessus, activer la méthode eXitByterrupt () et constater que la méthode Interrupt () est appelée dans le temps, et je cours ... (les résultats de différents systèmes et CPU peuvent être différents). On peut voir qu'il n'est pas sûr d'utiliser la méthode d'interruption.
Résumer
Selon l'analyse ci-dessus, la méthode la plus recommandée est la première. Nous pouvons définir des drapeaux en utilisant des variables partagées et envoyer des signaux pour informer le thread qu'il doit se terminer. Bien sûr, nous devons nous assurer que les opérations de cette variable partagée sont synchrones.
Ce qui précède est tout le contenu de cet article sur l'instance de thread de terminaison Java et la lecture du code source de la méthode stop (). J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!