Dans cet article, nous parlerons du mécanisme d'interruption d'interruption du thread Java Thread.
Interrompre le fil
La méthode thread.interrupt () du thread est d'interrompre le thread. Il définira le bit d'état d'interruption du thread, c'est-à-dire réglé sur true. Que le thread interrompu décède, attend une nouvelle tâche ou continue de fonctionner à l'étape suivante dépend du programme lui-même. Le thread détectera ce drapeau d'interruption de temps à autre pour déterminer si le fil doit être interrompu (si le drapeau d'interruption est vrai). Il n'interrompt pas un thread en cours d'exécution comme la méthode d'arrêt.
Déterminez si le fil est interrompu
Pour déterminer si un thread a envoyé une demande d'interruption, veuillez utiliser le thread.currentThread (). Isinterrupted () Méthode (car il n'effacera pas le bit d'indicateur d'interruption immédiatement après avoir réglé le bit d'interruption d'interruption de thread sur true, c'est-à-dire qu'il ne définira pas l'indicateur d'interruption sur False). Au lieu de cela, n'utilisez pas la méthode thread.interrupted () (le bit de l'interruption d'interruption sera effacé après que la méthode est appelée, c'est-à-dire réinitialiser avec False) la méthode pour juger. Ce qui suit est la méthode d'interruption du fil lorsqu'il est en boucle:
while (! thread.currentThread (). isInterrupted () && plus de travail à faire) {faire plus de travail}Indicateur d'interruption d'état
Il existe les méthodes suivantes dans le mécanisme d'interruption d'interruption:
Par conséquent, le mécanisme d'interruption d'interruption n'interrompt pas vraiment le thread actuel, mais un changement dans le balisage d'interruption. Tessons-le avec des exemples en premier.
Classe publique InterruptTest {// Le temps consommé ici est utilisé pour imprimer un temps statique privé longtemps = 0; private static void resettime () {time = System.currenttimemillis (); } private static void printContent (String Content) {System.out.println (contenu + "Time:" + (System.CurrentTimeMillis () - Time)); } public static void main (String [] args) {test1 (); } private static void test1 () {thread1 thread1 = new Thread1 (); thread1.start (); // Interruption d'interruption après 3 secondes de retard essayez {Thread.Sleep (3000); } catch (InterruptedException e) {e.printStackTrace (); } thread1.interrupt (); printContent ("Interruption d'exécution"); } classe statique privée Thread1 étend Thread {@Override public void run () {resettime (); int num = 0; while (true) {if (isInterrupted ()) {printContent ("Le thread actuel est Interrupted"); casser; } num ++; if (num% 100 == 0) {printContent ("num:" + num); }}}}}}}Le code ci-dessus est de démarrer un thread Thread1 et d'ajouter en continu 1 à Num dans la boucle WHOR du thread Thread1 et de l'imprimer une fois plusieurs de 100 (empêcher l'impression de trop rapidement). Ensuite, après avoir dormi pendant 3000 millisecondes, le thread principal appelle la méthode d'interruption du thread Thread1. Ensuite, regardons la sortie:
interruption d'interruption
On peut voir qu'après avoir pris environ 3000 millisecondes, c'est-à-dire après le sommeil du thread principal, le fil Thread1 s'arrête et le fil Thread1 s'arrête parce que la méthode ISinterrupted dans la boucle While Retour, donc Break sort la boucle while. C'est-à-dire que le rôle de l'interruption et est interrompu ici équivaut au rôle de SetXX et Getxx, en maintenant une variable booléenne.
Interrompre la gestion des exceptions
Bien sûr, le mécanisme d'interruption n'est pas seulement un changement et une détection des bits d'état d'interruption, il peut également gérer les exceptions d'interruption. Nous savons que la méthode thread.sleep () doit prendre l'exception d'interruption, alors ajoutons un délai de sommeil et essayons-le
while (true) {if (isInterrupted ()) {printContent ("Le thread actuel est Interrupted"); casser; } num ++; // Sleep Try {Thread.Sleep (1); } catch (InterruptedException e) {e.printStackTrace (); } if (num% 100 == 0) {printContent ("num:" + num); }}Regardons le résultat de la sortie:
interruption d'interruption
Ici, nous constaterons qu'après avoir dormi, la valeur de numéros de sortie est nettement plus petite (les nombres atteignent 1 milliard lorsqu'ils ne dorment pas, et il semble que le CPU effectue des opérations simples très rapidement). Haha, mais ce n'est pas le point. Le point est qu'après l'exception de sortie, la sortie ISInterrupted renvoie false et le thread Thread1 continue de s'exécuter et ne sort pas de la boucle while. Alors pourquoi est-ce? Nous avons juste ajouté un sommeil.
S'il y a une opération dans le thread Thread1 qui doit attraper l'exception InterruptedException, telles que le sommeil de Thread, la méthode de jointure, l'attente de l'objet, l'état de l'état, etc., il force l'exception InterruptedException à Catch, puis lorsque la méthode de thread1.Interrupt est appelée, il lancera une exception InterruptedException au thread Thread1. Ensuite, dans la boucle while, cette exception peut être capturée, puis après le lancement de cette exception, l'indicateur d'interruption du fil sera réinitialisé immédiatement à False. Par conséquent, lorsqu'il est interrompu dans la prochaine fois que la boucle while est déterminée comme fausse, elle ne se cassera pas, puis la boucle While continuera de s'exécuter.
Par conséquent, la méthode Interrupt () effectuera différentes opérations en fonction de la question de savoir s'il y a du code dans la méthode d'exécution dans le thread qui doit attraper l'interruptedException:
Scénarios d'application d'interruption
Habituellement, l'interruption convient aux jugements de marque de boucle dans l'exécution du thread, par exemple
tandis que (! isInterrupted ()) {...} Cependant, s'il y a un blocage dans cette boucle, le thread ne peut pas juger la balise suivante, et même si la méthode Interrupt () est appelée, elle ne peut pas quitter la boucle et le thread ne peut pas sortir. Par exemple
tandis que (! isInterrupted ()) {... tandis que (true) {// Le thread est coincé ici, le mécanisme interrompu ne peut pas être répondu à}}De cette façon, l'interruption sera impuissante, et le fil continuera de s'exécuter et ne sera pas interrompu et arrêté.
Tester des exemples pour voir mon github - Javatest
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.