Parfois, les suspensions de fil sont utiles. Par exemple, un fil séparé peut être utilisé pour afficher l'heure de la journée. Si l'utilisateur ne souhaite pas utiliser l'horloge, le fil est suspendu. Dans tous les cas, la suspension du fil est très simple, et une fois en suspension, redémarrer le fil est également une question simple.
Les mécanismes de suspension, de terminaison et de restauration des fils diffèrent dans les versions Java 2 et antérieures. Bien que vous utilisiez Java 2 pour écrire du code, vous devez toujours comprendre comment ces opérations ont été effectuées dans l'environnement Java précoce. Par exemple, vous devrez peut-être mettre à jour ou maintenir un ancien code. Vous devez également comprendre pourquoi Java 2 a de tels changements. Pour ces raisons, ce qui suit décrit la méthode d'origine d'exécution du contrôle du thread, suivie de la méthode Java 2.
Pause, récupération et résiliation des fils dans Java 1.1 ou plus tôt
Avant la version Java2, le programme utilise Suspend () et repseMe () défini par le thread pour faire une pause et redémarrer les threads. Ils sont sous la forme de:
VOID final suspendre () final void remer ()
La procédure suivante décrit ces méthodes:
// Utilisation de Suspende (Repumed (). Out .println ("Nouveau thread:" + t); t.start (); I> 0; i--) {System.out.println (nom + ":" + i); ":::::::::::::::::::::::::::::::::::- ::::::::::::::);} System.out.println (name + "Exécution."); newthread (un "); .Sleed (1000); ob1.t.Resume (); Sleep (1000); OB2.T.Resume (); Attendez que les threads finissent {System.out.println (en attente de threads pour terminer. "); ob1.t.join (); Println ("Filant principal interrompu");} System.o ut.println ("Filant principal de la sortie."); Une partie de la sortie du programme est la suivante:
Nouveau thread: Thread [One, 5, Main] One: 15New Thread: Thread [Two, 5, Main] Two: 15One: 14two: 14One: 13Two: 13One: 12two: 11two: 11SUSSENSED Thread Onetwo: 10two: 9two: 8two: 7Two: 6 Résistance Thread OneSending Thread TwoOne: 10one: 9one: 8one: 7one: 6 Réflexion Twowaiting pour les threads à terminer.two: 5one: 5two: 4one: 4two: 3one .
La classe de thread définit également stop () pour terminer le thread. Sa forme est la suivante:
vide stop ()
Une fois le thread terminé, il ne peut pas être repris par repume () pour continuer à fonctionner.
Suspendre, restaurer et résilier les fils de Java
Les méthodes Suspend (), Repi () et STOP () définies par le thread semblent être des moyens parfaits et pratiques de gérer les threads, et ils ne peuvent pas être utilisés dans les nouvelles versions Java des programmes. Voici les raisons. La méthode suspend () de la classe de thread n'est pas favorisée dans Java2, car Suspend () peut parfois provoquer de graves défaillances du système. En supposant qu'un fil pour une structure de données critique est verrouillé, si le thread y est suspendu, les threads verrouillés n'abandonnent pas le contrôle de la ressource. D'autres fils en attente de ces ressources peuvent être bloqués.
La méthode repi () n'est pas non plus approuvée. Il ne cause pas de problèmes, mais ne peut être utilisé indépendamment sans la méthode suspend (). La méthode stop () de la classe de threads est également opposée dans Java 2. En effet, cette méthode peut provoquer de graves défaillances du système. Imaginez qu'un fil écrit une structure de données précise et importante et en terminer une seule fraction. Si le thread se termine en ce moment, la structure de données peut rester dans un état de crash.
Parce que dans Java 2, Suspend (), Repi () et les méthodes STOP () ne peuvent pas être utilisés pour contrôler les threads, vous pouvez penser qu'il n'y a aucun moyen d'arrêter, de restaurer et de terminer les threads. En fait, ce n'est pas le cas. Au lieu de cela, le thread doit être conçu de sorte que la méthode run () vérifie périodiquement pour déterminer si le thread doit être suspendu, reprendre ou résilier sa propre exécution. Représentant, cela se fait en établissant une variable de drapeau indiquant l'état du thread. Tant que l'indicateur est défini sur "Running", la méthode run () doit continuer à être exécutée par le thread. Si le drapeau est «suspendre», le fil doit être interrompu. S'il est réglé sur "Stop", le fil doit être terminé.
Bien sûr, il existe de nombreuses façons d'écrire un tel code, mais le sujet central devrait être le même pour tous les programmes.
Les exemples suivants illustrent comment les méthodes Wait () et Notify () héritées de l'objet contrôlent l'exécution des threads. Cet exemple est très similaire au programme mentionné précédemment. Cependant, aucune des méthodes non approuvées n'est utile. Réfléchissons à l'exécution du programme.
La classe NewTread contient la variable d'instance SuspendFlag utilisée pour contrôler l'exécution d'un thread. Il est initialisé en faux par le constructeur. La méthode run () contient un bloc qui surveille la déclaration de synchronisation de SuspendFlag. Si la variable est vraie, la méthode Wait () est appelée pour suspendre le thread. La méthode MySUSPEND () définit SuspendFlag sur true. La méthode MyResume () définit SuspendFlag sur false et appelle la méthode notify () pour évoquer le thread. Enfin, la méthode Main () est modifiée pour appeler les méthodes MySUSPend () et MyResume ().
// suspendre et récupérer un fil pour Java2Class NewThread implémente {String Name; Out .println ("Nouveau thread:" + t); t i = 15; i> 0; } rès void MyResume () {SuspendFlag = false; ; Le thread one "); ob2.mysUsPend (); System.out.println (" Suspende Thread Two "); Thread.Sleep (1000); OB2.Myresume (); System.out.println (" Resuming Thread T wo ") ; t.join (); ob2 }La sortie de ce programme est la même que celle du programme précédent. Plus tard dans ce livre, vous verrez plus d'exemples d'utilisation du mécanisme Java 2 pour contrôler les threads. Bien que ce mécanisme ne soit pas aussi "propre" que l'ancienne méthode, cependant, c'est le moyen de garantir qu'aucune erreur ne se produise au moment de l'exécution. C'est la méthode que tout le nouveau code doit prendre.