Kopieren Sie den Codecode wie folgt:
// Thread starten
public void start( );
public void run( );
// 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;
1. Threads erstellen und ausführen
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.
Kopieren Sie den Codecode wie folgt:
Paket Kapitel2;
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());
}
}
Bitte beachten Sie, dass im obigen Code die Join-Methode verwendet wird. Die Hauptfunktion dieser Methode besteht darin, sicherzustellen, dass das Programm nach Abschluss der Thread-Ausführungsmethode weiter ausgeführt wird. Diese Methode wird in einem späteren Artikel vorgestellt.
Das Ergebnis der Ausführung des obigen Codes:
isAlive: falsch
isAlive: wahr
Thread1 ist beendet!
isAlive: falsch
2. Threads anhalten und aktivieren
Sobald der Thread mit der Ausführung der Ausführungsmethode beginnt, wird er erst beendet, wenn die Ausführungsmethode abgeschlossen ist. Während der Ausführung des Threads können Sie die Thread-Ausführung jedoch über zwei Methoden vorübergehend stoppen. Diese beiden Methoden sind Suspend und Sleep. Nachdem Sie einen Thread mit Suspend angehalten haben, können Sie ihn ü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.
Kopieren Sie den Codecode wie folgt:
Paket Kapitel2;
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();
}
}
}
Oberflächlich betrachtet sind die Auswirkungen der Verwendung von Sleep und Suspend ähnlich, aber die Sleep-Methode ist nicht gleichbedeutend mit Suspend. Der größte Unterschied besteht darin, dass Sie mit der Suspend-Methode einen anderen Thread in einem Thread anhalten können. Im obigen Code wird beispielsweise der Thread-Thread im Haupt-Thread angehalten. Sleep funktioniert nur für den aktuell ausgeführten Thread. Im obigen Code ruhen SleepThread und der Hauptthread 2 Sekunden bzw. 5 Sekunden lang. Beachten Sie bei der Verwendung von Sleep, dass Sie nicht einen Thread in einem anderen Thread in den Ruhezustand versetzen können. Beispielsweise kann die Verwendung der Methode thread.sleep (2000) in der Hauptmethode den Thread-Thread nicht für 2 Sekunden in den Ruhezustand versetzen, sondern nur den Haupt-Thread für 2 Sekunden in den Ruhezustand versetzen.
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. Throws oder try{...}catch{...} müssen verwendet werden, wenn die Sleep-Methode verwendet wird. Da die run-Methode keine Würfe verwenden kann, können Sie nur try{...}catch{...} verwenden. Wenn der Thread schläft und die Interrupt-Methode (diese Methode wird in 2.3.3 besprochen) zum Unterbrechen des Threads verwendet wird, löst Sleep eine InterruptedException aus. Die Schlafmethode ist wie folgt definiert:
Kopieren Sie den Codecode wie folgt:
public static void sleep(long millis) löst eine InterruptedException aus
public static void sleep(long millis, int nanos) löst eine InterruptedException aus
3. Drei Möglichkeiten, einen Thread zu beenden
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 bestimmten Bedingungen 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.
Kopieren Sie den Codecode wie folgt:
Paket Kapitel2;
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!");
}
}
Im obigen Code ist ein Exit-Flag namens „exit“ definiert. Wenn „exit“ den Wert „true“ hat, wird die while-Schleife beendet und der Standardwert von „exit“ ist „false“. Bei der Definition von Exit wird ein Java-Schlüsselwort volatile verwendet. Der Zweck dieses Schlüsselworts besteht darin, Exit zu synchronisieren, was bedeutet, dass nur ein Thread gleichzeitig den Wert von Exit ändern kann.
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:
thread.stop();
Obwohl die Verwendung des obigen Codes den Thread beenden kann, ist die Verwendung der Stoppmethode ebenso gefährlich wie das plötzliche Ausschalten des Computers anstelle des normalen Herunterfahrens. Daher wird die Verwendung nicht empfohlen die Stop-Methode. Beenden Sie den Thread.
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.
Kopieren Sie den Codecode wie folgt:
Paket Kapitel2;
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!");
}
}
Die Ergebnisse der Ausführung des obigen Codes sind wie folgt:
Kopieren Sie den Codecode wie folgt:
Drücken Sie innerhalb von 50 Sekunden eine beliebige Taste, um den Thread zu unterbrechen!
Schlaf unterbrochen
Der Thread wurde beendet!
Nach dem Aufruf der Interrupt-Methode löst die Sleep-Methode eine Ausnahme aus und gibt dann die Fehlermeldung aus: Sleep unterbrochen.
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.