In diesem Artikel werden wir über den Interrupt -Interrupt -Mechanismus des Java -Thread -Threads sprechen.
Thread unterbrechen
Die Methode von Thread.Interrupt () des Threads besteht darin, den Thread zu unterbrechen. Es wird das Interrupt -Statusbit des Threads festgelegt, dh auf true festgelegt. Unabhängig davon, ob der unterbrochene Thread stirbt, auf eine neue Aufgabe wartet oder weiter zum nächsten Schritt läuft, hängt vom Programm selbst ab. Der Thread erkennt dieses Interrupt -Flag von Zeit zu Zeit, um festzustellen, ob der Thread unterbrochen werden sollte (ob das Interrupt -Flag wahr ist). Es unterbricht keinen laufenden Thread wie die Stop -Methode.
Bestimmen Sie, ob der Faden unterbrochen wird
Um festzustellen, ob ein Thread eine Interrupt -Anforderung gesendet hat, verwenden Sie bitte den Thread.CurrentThread (). Isinterrupted () (da das Interrupt -Flag -Bit nicht sofort nach dem Einstellen des Thread -Interrupt -Flag -Bits auf True löscht, dh das Interrupt -Flag wird nicht auf False festgelegt. Verwenden Sie stattdessen nicht die Methode, die die Methode aufgerufen wurde. Das Folgende ist die Interrupt -Methode des Threads, wenn er sich in einer Schleife befindet:
while (! thread.currentthread (). isinterrupted () && mehr Arbeit) {machen Sie mehr Arbeit}Interrupt Status Flag
Im Interrupt -Interrupt -Mechanismus gibt es die folgenden Methoden:
Daher unterbricht der Interrupt -Interrupt -Mechanismus den aktuellen Thread nicht wirklich, sondern eine Änderung des Interrupt -Markups. Testen wir es zuerst mit Beispielen.
öffentliche Klasse InterruptTest {// Die hier konsumierte Zeit dient zum Drucken privater statischer langer Zeit = 0; private static void Reettime () {time = system.currentTimillis (); } private static void printContent (String -Inhalt) {System.out.println (Inhalt + "Zeit:" + (System.currentTimemillis () - Zeit)); } public static void main (String [] args) {Test1 (); } private static void test1 () {Thread1 Thread1 = neuer Thread1 (); Thread1.Start (); // Interrupt Interrupt nach 3 Sekunden Verzögerung try {thread.sleep (3000); } catch (interruptedException e) {e.printstacktrace (); } thread1.interrupt (); printContent ("Ausführung Interrupt"); } private statische Klasse Thread1 erweitert Thread {@Override public void run () {Reettime (); int num = 0; while (true) {if (isInterrupted ()) {printContent ("aktueller Thread is interrupted"); brechen; } num ++; if (num % 100 == 0) {printContent ("num:" + num); }}}}}}}Der obige Code soll einen Thread1 -Thread starten und kontinuierlich 1 in die while -Schleife des Thread1 -Threads addieren und einmal jedes mehrfache von 100 drucken (verhindern, dass der Druck zu schnell ist). Nach dem Schlafengehen für 3000 Millisekunden ruft der Hauptfaden die Interrupt -Methode des Thread1 -Threads auf. Dann schauen wir uns die Ausgabe an:
Interrupt Interrupt
Es ist ersichtlich, dass nach dem Einnehmen von etwa 3000 Millisekunden, dh nach dem Hauptfaden, der Thread1 -Thread stoppt und der Thread1 -Thread stoppt, da die unterbrochene Methode in der while -Schleife wahr zurückgibt. Das heißt, die Rolle von Interrupt und hier entspricht hier der Rolle von SetXX und GETXX, wobei eine boolesche Variable beibehalten wird.
Interrupt -Ausnahmebehandlung unterbrechen
Natürlich ist der Interrupt -Mechanismus nicht nur eine Änderung und Erkennung von Interrupt -Status -Bits, sondern auch die Interrupt -Ausnahmen. Wir wissen, dass die Methode der Thread.sleep () die Interrupt -Ausnahme erfassen muss. Fügen wir also eine Schlafverzögerung hinzu und versuchen Sie es
while (true) {if (isInterrupted ()) {printContent ("aktueller Thread is interrupted"); brechen; } num ++; // schlafe versuche {thread.sleep (1); } catch (interruptedException e) {e.printstacktrace (); } if (num % 100 == 0) {printContent ("num:" + num); }}Schauen wir uns das Ausgabeergebnis an:
Interrupt Interrupt
Hier werden wir feststellen, dass nach dem Schlafengehen der Ausgangsnummwert erheblich kleiner ist (NUMs erreichen 1 Milliarde, wenn sie nicht schlafen, und es scheint, dass die CPU sehr schnell einfache Operationen ausführt). Haha, aber das ist nicht der Punkt. Der Punkt ist, dass nach der Ausnahmeausnahme die IS -Inrupted -Ausgabe false zurückgibt und der Thread1 -Thread weiterhin ausgeführt wird und die while -Schleife nicht beendet. Warum ist das? Wir haben gerade einen Schlaf hinzugefügt.
Wenn im Thread1 -Thread eine Operation vorhanden ist, die die InterruptedException -Ausnahme erfassen muss, z. B. den Schlaf von Thread, die Join -Methode, die Wartezeit des Objekts, die Konditionserhaltung usw., erzwingt die InterruptedException -Ausnahme, wenn die Thread1 -Methode aufgerufen wird. Dann kann diese Ausnahme in der while -Schleife gefangen werden und nach dieser Ausnahme wird das Faden -Interrupt -Flag sofort auf falsch zurückgesetzt. Wenn es beim nächsten Mal festgelegt wird, dass die Schleife falsch ist, wird sie nicht brechen, und dann wird die while -Schleife weiter ausgeführt.
Daher führt die Interrupt () -Methode unterschiedliche Operationen aus, basierend darauf, ob im Thread -Thread Code in der Run -Methode vorhanden ist, die die InterruptedException aufnehmen muss:
Anwendungsszenarien von Interrupt
Normalerweise eignet sich Interrupt für Schleifenmarkierungsurteile in der Thread -Ausführung beispielsweise für die Thread -Ausführung
while (! ist interrupted ()) {...} Wenn in dieser Schleife jedoch eine Blockade vorliegt, kann der Thread nicht beurteilen, dass das nächste ist, und selbst wenn die Interrupt () -Methode aufgerufen wird, kann er die Schleife nicht beenden und der Thread kann nicht beenden. Zum Beispiel
while (! is interrupted ()) {... wobAuf diese Weise wird Interrupt hilflos sein und der Thread wird weiterhin ausgeführt und nicht unterbrochen und gestoppt.
Testbeispiele, um meinen Github-Javatest zu sehen
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.