Der Faden -Interrupt -Mechanismus bietet eine Methode zum Aufwachen eines Fadens aus einer Blockierungswartung, wobei versucht wird, den vorhandenen Verarbeitungsfluss des Ziel -Threads zu unterbrechen und auf neue Befehle zu reagieren. Java überlasst diese Freiheit den Entwicklern, und wir sollten sie gut nutzen.
Heute werden wir über den Interrupt -Mechanismus von Java -Threads sprechen.
Der Faden -Interrupt -Mechanismus bietet eine Methode mit zwei gemeinsamen Verwendungen:
Wecken Sie den Faden vom Blockieren des Wartens und erstellen Sie die entsprechende "kontrollierte Interrupt" -Verwicklung.
Versuchen Sie, den Ziel -Thread zu informieren: Bitte unterbrechen Sie den vorhandenen Verarbeitungsfluss und antworten Sie auf neue Befehle.
Nehmen Sie den ersten Zweck als Beispiel. Weitere Informationen finden Sie im folgenden Code:
synchronisiert (lock) {try {while (! check ()) {lock.wait (1000); }} catch (interruptedException e) {e.printstacktrace (); }}Dieser Code verwendet den von Java bereitgestellten Warte-/Benachrichtigungsmechanismus. Die Thread -Ausführung von lock.wait () blockiert. Es gibt drei Situationen, in denen der Faden wiederhergestellt werden soll.
1. Timeout 1000ms endet und der nächste Code wird normal ausgeführt.
2. Ein anderer Thread führt den folgenden Code aus, um aktiv aufzuwachen
synchronisiert (lock) {lock.notifyAll (); // oder lock.notify ();}Dadurch wird auch der nächste Code normalerweise ausgeführt.
3. Ein weiterer Thread, auf den warten müssen, ist "Interrupt"
// den Verweis auf den wartenden Thread -Thread A; a.interrupt () erhalten;
Thread A, das "unterbrochen" wird, wirft eine InterruptedException -Ausnahme bei lock.wait () aus.
Zusammenfassend können Sie Objekt denken.
boolean checkTimeout = timeout> 0; Thread current = thread.currentThread (); lock.addWaiter (current); while (! current.isnotified ()) {if (aktuell neue InterruptedException () werfen; } if (checkTimeout) {if (timeout == 0) break; Time-out--; }}Dies ist nicht ganz genau, da das Warten diese "geschäftige Umfragemethode" nicht verwendet, um zu überprüfen, aber die Logik der Beurteilung von Flag -Bits ist korrekt.
Beginnen wir mit dem oben erwähnten "Manuell ausstellen" -Orgo -Operation "
// sun.nio.ch.InterruptiblePublic Interface Interruptible {void interrupt (Thread var1);} // java.lang.Threadprivate volatile interruptible Blocker; synchronisiert (BlockerLock) {interruptible b = Blocker; if (b! = null) {interrupt0 (); b.interrupt (this); zurückkehren; }} interrupt0 ();} // nur um den Interrupt -Flagprivate native void interrupt0 () festlegen;Es ist zu sehen, dass Thread.interrupt () zuerst Berechtigungen beurteilt und dann tatsächlich Interrupt0 () aufruft, um das Interrupt -Flag des Threads festzulegen. Wenn der aktuelle Thread von Nios unterbrochen ist, wird auch er zurückgerufen.
Beachten Sie, dass Interrupt0 () nur das Interrupt -Flag des Threads festlegt.
Was passiert, wenn ein Thread nicht blockiert und nicht in Bereichen ist, die nicht von der Java -Programmlogik wie Object.wait (), Thread.join (), Thread.sleep () gesteuert werden? Die Antwort ist, dass nichts passieren wird und ob der Thread unterbrochen wird, kann nur durch aktives Überprüfen der Interrupt -Flagge bekannt sein.
Wie checkt ich nach? Thread enthält zwei Schnittstellen, Thread.Interrupted () und Thread.Interrupted ().
// java.lang.threadpublic static boolean interrupted () {return currentThread (). ist unterbrochen (true);} public boolean ist interruptiert () {return is unterbrochen (falsch);} privat native boolean is interrupted (boolean klare Interrupted);Es ist zu erkennen, dass beide auf das Innen angewiesen sind (boolean), was zurückgibt, ob der Thread unterbrochen wird, und das Interrupt -Flag nach Bedarf zu löschen.
Wenn ein Funktionsaufruf blockiert, löscht die Funktionsfunktion der Java -Bibliothek die InterruptedException in die Signatur der Blockierungsquelle und erfordert den Schreibversuch, um Interrupts zu verarbeiten.
Wenn der Thread wie oben erwähnt blockiert, überprüft Java nach dem Interrupt -Flag zuerst und wirft dann eine InterruptedException aus.
// Java.lang.ObjectPublic Final void Wait () löscht InterruptedException {Wait (0);} öffentliche endgültige native void wait (langfristig) aus.Wenn ein Thread eine InterruptedException erhält und dann den Code ausführt, der eine Blockierung ausführt, blockiert er weiterhin wie "egal". Weil Java die Interrupt -Flagge intern löscht!
Wir schreiben häufig die folgenden drei Arten von Code, die die InterruptedException verarbeiten:
Behandeln Sie die InterruptedException zur oberen Schicht zur Verarbeitung.
public void foo () löscht InterruptedException {synchronisierte (lock) {lock.wait (); }}InterruptedException setzte das Interrupt -Flag -Bit zurück.
try {synchronized (lock) {lock.wait (); }} catch (InterruptedException e) {thread.currentThread (). interrupt (); //brechen; }Beenden Sie zuerst Ihre Arbeit und werfen Sie dann erneut eine InterruptedException.
public void bar () wirft InterruptedException {InterruptedException IE = NULL aus; boolean erledigt = falsch; while (! Done) {synchronized (lock) {try {lock.wait (); } catch (InterruptedException e) {ie = e; weitermachen; }} cone = true; } if (dh! = null) {throw ie; }}Wenn ein Faden das Interrupt -Flag und die InterruptedException ignoriert, läuft er immer noch gut. Dies steht jedoch im Widerspruch zu unserer ursprünglichen Absicht, Multithreading zu entwerfen. Wir möchten, dass Threads harmonisch und ordentlich zusammenarbeiten, um bestimmte Funktionen zu erwerben, sodass kontrollierte Threads auf Interrupts reagieren sollten. Und wir sollten diese Freiheit, die Java den Entwicklern hinterlassen hat, gut nutzen.
Das obige ist das relevante Wissen über den Java -Thread -Interrupt -Mechanismus, der Ihnen dieses Mal vorgelegt wurde. Wenn Sie nichts verstehen, können Sie es im Nachrichtenbereich unten besprechen. Vielen Dank für Ihre Unterstützung für Wulin.com.