So wie Menschen geboren, alt, krank und sterben, müssen auch Threads vier verschiedene Zustände durchlaufen: Starten (Warten), Laufen, Hängen und Stoppen. Diese vier Zustände können durch Methoden in der Thread-Klasse gesteuert werden. Die Methoden, die sich auf diese vier Zustände in der Thread-Klasse beziehen, sind unten aufgeführt.
// Threads anhalten und aktivieren
public void resume( ); // Nicht zur Verwendung empfohlen
public void suspend( ); // Nicht zur Verwendung empfohlen
öffentlicher statischer leerer Schlaf (lange Millisekunden);
öffentlicher statischer leerer Schlaf (lange Millisekunden, int Nanos);
// Thread beenden
public void stop( ); // Nicht zur Verwendung empfohlen
public void interrupt( );
// Thread-Status abrufen
public boolean isAlive( );
öffentlicher boolescher Wert isInterrupted( );
öffentlicher statischer boolescher Wert interrupted( );
// Join-Methode
public void join( ) throws InterruptedException;
Der Thread führt den Code in der Ausführungsmethode nicht unmittelbar nach seiner Einrichtung aus, sondern befindet sich im Wartezustand. Wenn sich der Thread im Wartezustand befindet, können Sie über die Methoden der Thread-Klasse verschiedene Attribute des Threads festlegen, z. B. die Priorität des Threads (setPriority), den Thread-Namen (setName) und den Thread-Typ (setDaemon).
Wenn die Startmethode aufgerufen wird, beginnt der Thread mit der Ausführung des Codes in der Run-Methode. Der Thread wechselt in den laufenden Zustand. Sie können die isAlive-Methode der Thread-Klasse verwenden, um festzustellen, ob der Thread ausgeführt wird. Wenn sich der Thread im laufenden Zustand befindet, gibt isAlive „true“ zurück. Wenn isAlive „false“ zurückgibt, befindet sich der Thread möglicherweise im Wartezustand oder im gestoppten Zustand. Der folgende Code demonstriert den Wechsel zwischen den drei Zuständen Thread-Erstellung, Ausführung und Stopp und gibt den entsprechenden isAlive-Rückgabewert aus.
Die öffentliche Klasse LifeCycle erweitert Thread
{
public void run()
{
int n = 0;
while ((++n) < 1000);
}
public static void main(String[] args) löst eine Ausnahme aus
{
LifeCycle thread1 = new LifeCycle();
System.out.println("isAlive: " + thread1.isAlive());
thread1.start();
System.out.println("isAlive: " + thread1.isAlive());
thread1.join(); // Warten Sie, bis Thread Thread1 endet, bevor Sie mit der Ausführung fortfahren
System.out.println("thread1 ist beendet!");
System.out.println("isAlive: " + thread1.isAlive());
}
}
Das Ergebnis der Ausführung des obigen Codes:
Sobald der Thread mit der Ausführung der Ausführungsmethode beginnt, wird er erst beendet, wenn die Ausführungsmethode abgeschlossen ist. Während der Thread-Ausführung gibt es jedoch zwei Methoden, mit denen die Thread-Ausführung vorübergehend gestoppt werden kann. Diese beiden Methoden sind Suspend und Sleep. Nachdem Sie den Thread mit Suspend angehalten haben, können Sie den Thread über die Resume-Methode aktivieren. Nachdem der Thread mit Sleep in den Ruhezustand versetzt wurde, kann er sich erst nach der festgelegten Zeit im Bereitschaftszustand befinden (nachdem der Thread-Ruhezustand endet, wird der Thread möglicherweise nicht sofort ausgeführt, sondern wechselt nur in den Bereitschaftszustand und wartet auf die Planung durch das System). .
Obwohl Suspend und Resume Threads leicht anhalten und aufwecken können, kann die Verwendung dieser beiden Methoden dazu führen, dass einige unvorhersehbare Dinge passieren. Daher werden diese beiden Methoden als veraltet (Protest) markiert, was darauf hinweist, dass diese beiden Methoden in zukünftigen JDKs möglicherweise gelöscht werden Versuchen Sie daher, diese beiden Methoden nicht zum Betreiben von Threads zu verwenden. Der folgende Code demonstriert die Verwendung der Sleep-, Suspend- und Resume-Methoden.
Die öffentliche Klasse MyThread erweitert Thread
{
Die Klasse SleepThread erweitert Thread
{
public void run()
{
versuchen
{
Schlaf (2000);
}
Catch (Ausnahme e)
{
}
}
}
public void run()
{
while(true)
System.out.println(new java.util.Date().getTime());
}
public static void main(String[] args) löst eine Ausnahme aus
{
MyThread thread = new MyThread();
SleepThread sleepThread = thread.new SleepThread();
sleepThread.start(); // Starten Sie die Ausführung des Threads sleepThread
sleepThread.join(); // Thread-SleepThread um 2 Sekunden verzögern
thread.start();
boolesches Flag = false;
while(true)
{
sleep(5000); // Den Hauptthread um 5 Sekunden verzögern
flag = !flag;
wenn (Flagge)
thread.suspend();
anders
thread.resume();
}
}
}
Bei der Anwendung der Schlafmethode sind zwei Punkte zu beachten:
1. Die Schlafmethode hat zwei überladene Formen. Eine der überladenen Formen kann nicht nur Millisekunden, sondern auch Nanosekunden festlegen (1.000.000 Nanosekunden entsprechen 1 Millisekunde). Allerdings ist die Java Virtual Machine auf den meisten Betriebssystemplattformen nicht auf Nanosekunden genau. Wenn daher Nanosekunden für den Ruhezustand eingestellt sind, verwendet die Java Virtual Machine die Millisekunde, die diesem Wert am nächsten kommt.
2. Wenn Sie die Sleep-Methode verwenden, müssen Sie throws oder try{…}catch{…} verwenden. Da die run-Methode keine throws verwenden kann, können Sie nur try{…}catch{…} verwenden löst eine InterruptedException aus, wenn ein Thread mit der Interrupt-Methode unterbrochen wird (diese Methode wird in 2.3.3 besprochen). Die Schlafmethode ist wie folgt definiert:
Es gibt drei Möglichkeiten, einen Thread zu beenden.
1. Verwenden Sie das Exit-Flag, um den Thread normal zu beenden, dh der Thread wird beendet, wenn die Ausführungsmethode abgeschlossen ist.
2. Verwenden Sie die Stopp-Methode, um den Thread zwangsweise zu beenden (diese Methode wird nicht empfohlen, da Stoppen ebenso wie Suspend und Resume zu unvorhersehbaren Ergebnissen führen kann).
3. Verwenden Sie die Interrupt-Methode, um den Thread zu unterbrechen.
1. Beenden Sie den Thread mit dem Exit-Flag
Wenn die run-Methode ausgeführt wird, wird der Thread beendet. Aber manchmal endet die Ausführungsmethode nie. Beispielsweise werden Threads in Serverprogrammen verwendet, um Client-Anfragen oder andere Aufgaben zu überwachen, die eine zyklische Verarbeitung erfordern. In diesem Fall werden diese Aufgaben normalerweise in einer Schleife, beispielsweise einer While-Schleife, platziert. Wenn Sie möchten, dass die Schleife ewig läuft, können Sie while(true){...} verwenden, um damit umzugehen. Wenn Sie jedoch möchten, dass die While-Schleife unter einer bestimmten Bedingung beendet wird, besteht der direkteste Weg darin, ein boolesches Flag zu setzen und dieses Flag auf true oder false zu setzen, um zu steuern, ob die While-Schleife beendet wird. Nachfolgend finden Sie ein Beispiel für das Beenden eines Threads mithilfe des Exit-Flags.
Die öffentliche Klasse ThreadFlag erweitert Thread
{
öffentlicher flüchtiger boolescher Ausgang = false;
public void run()
{
while (!exit);
}
public static void main(String[] args) löst eine Ausnahme aus
{
ThreadFlag thread = new ThreadFlag();
thread.start();
sleep(5000); //Der Hauptthread verzögert sich um 5 Sekunden
thread.exit = true; // Thread beenden
thread.join();
System.out.println("Thread beendet!");
}
}
2. Verwenden Sie die Stop-Methode, um den Thread zu beenden
Verwenden Sie die Stop-Methode, um einen laufenden oder angehaltenen Thread zwangsweise zu beenden. Wir können den folgenden Code verwenden, um den Thread zu beenden:
3. Verwenden Sie die Interrupt-Methode, um den Thread zu beenden
Die Verwendung der Interrupt-Methode zum Beenden eines Threads kann in zwei Situationen unterteilt werden:
(1) Der Thread befindet sich in einem blockierten Zustand, z. B. bei Verwendung der Schlafmethode.
(2) Verwenden Sie while(!isInterrupted()){...}, um festzustellen, ob der Thread unterbrochen ist.
Im ersten Fall löst die Sleep-Methode bei Verwendung der Interrupt-Methode eine InterruptedException-Ausnahme aus, während im zweiten Fall der Thread direkt beendet wird. Der folgende Code demonstriert die Verwendung der Interrupt-Methode im ersten Fall.
Die öffentliche Klasse ThreadInterrupt erweitert Thread
{
public void run()
{
versuchen
{
Sleep(50000); // Verzögerung 50 Sekunden
}
Catch (InterruptedException e)
{
System.out.println(e.getMessage());
}
}
public static void main(String[] args) löst eine Ausnahme aus
{
Thread thread = new ThreadInterrupt();
thread.start();
System.out.println("Drücken Sie innerhalb von 50 Sekunden eine beliebige Taste, um den Thread zu unterbrechen!");
System.in.read();
thread.interrupt();
thread.join();
System.out.println("Der Thread wurde beendet!");
}
}
Schlaf unterbrochen
Der Thread wurde beendet!
Hinweis: In der Thread-Klasse gibt es zwei Methoden, um zu bestimmen, ob der Thread durch die Interrupt-Methode beendet wird. Eine davon ist die statische Methode interrupted() und die andere die nicht statische Methode isInterrupted(). Der Unterschied zwischen diesen beiden Methoden besteht darin, dass interrupted verwendet wird, um zu bestimmen, ob der aktuelle Thread unterbrochen ist, während isInterrupted verwendet werden kann, um festzustellen, ob der aktuelle Thread unterbrochen ist Andere Threads werden unterbrochen. Daher kann while (!isInterrupted()) auch durch while (!Thread.interrupted()) ersetzt werden.