Detaillierte Erläuterung der fünf Zustände von Java-Threads und Zustandsübergangsregeln

Umfassendes Verständnis der fünf Zustände von Java-Threads und ihrer Konvertierungsregeln

1 Einführung in die fünf Zustände von Threads
In Java kann der Lebenszyklus eines Threads in fünf verschiedene Zustände unterteilt werden, einschließlich der neuer Zustand (NEW), Bereitschaftszustand (RUNNABLE), laufender Zustand (RUNNING), blockierter Zustand (BLOCKED) und beendeter Zustand (TERMINATED).

1. Neuer Zustand (NEU): Wenn das Thread-Objekt erstellt wird, befindet es sich im neuen Zustand. Zu diesem Zeitpunkt hat das Thread-Objekt genügend Ressourcen zugewiesen, um die Aufgabe auszuführen, hat aber noch nicht mit der Ausführung der run()-Methode begonnen.
2. Bereitschaftszustand (RUNNABLE): Wenn der Thread die start()-Methode aufruft, wechselt der Thread in den Bereitschaftszustand. Der Thread im Bereitschaftszustand verfügt über die Bedingungen zum Ausführen und wartet darauf, dass die CPU ein Zeitsegment für die Ausführung des Codes zuweist.
3. Ausführungsstatus (RUNNING): Wenn der Thread im Bereitschaftsstatus das CPU-Zeitsegment erhält, wechselt er in den Ausführungsstatus und beginnt mit der Ausführung des Codes in der run()-Methode. Der Thread läuft weiter, bis er sich selbst beendet oder von einem anderen Thread unterbrochen wird.

4. Blockierter Zustand (BLOCKED): Unter den folgenden Umständen wechselt der Thread in den blockierten Zustand:

   • Die Methode sleep() wird aufgerufen und die CPU-Ressourcen werden aktiv aufgegeben.
   • Warten auf die Freigabe einer Ressource, beispielsweise einer gesperrten Ressource.
   • Threads warten auf den Abschluss anderer Threads in der Methode join().
5. Beendeter Zustand (TERMINATED): Nachdem der Thread beendet ist, wechselt er in den beendeten Zustand. Nachdem der Thread die Ausführung des Codes in der run()-Methode abgeschlossen hat oder der Thread aufgrund einer Ausnahme oder aus anderen Gründen beendet wurde, wechselt der Thread in den beendeten Zustand.

2. Konvertierungsregeln zwischen Staaten
Es gibt bestimmte Konvertierungsregeln zwischen Thread-Staaten. Im Folgenden stellen wir die Konvertierungsregeln zwischen den einzelnen Staaten vor.

1. Neuer Zustand (NEW) wird in den Bereitschaftszustand (RUNNABLE) umgewandelt: Wenn das Thread-Objekt erstellt und die start()-Methode aufgerufen wird, wird der Thread vom neuen Zustand in den Bereitschaftszustand umgewandelt.
2. Konvertieren Sie den Bereitschaftszustand (RUNNABLE) in den Ausführungszustand (RUNNING): Wenn der Thread die CPU-Ressourcen erhält, wechselt er vom Bereitschaftszustand in den Ausführungszustand.
3. Konvertieren des laufenden Zustands (RUNNING) in den blockierenden Zustand (BLOCKED): Während der Ausführung kann der Thread in den blockierenden Zustand wechseln, weil er auf die Freigabe einer Ressource wartet oder aktiv CPU-Ressourcen freigibt.
4. Konvertieren Sie den Blockierungsstatus (BLOCKED) in den Bereitschaftsstatus (RUNNABLE): Wenn die Ressource, auf die der Thread wartet, freigegeben wird oder die Wartezeit abläuft, wechselt er vom Blockierungsstatus in den Bereitschaftsstatus.
5. Konvertieren des laufenden Zustands (RUNNING) in den beendeten Zustand (TERMINATED): Wenn die run()-Methode des Threads abgeschlossen ist oder der Thread aufgrund einer Ausnahme beendet wird, wechselt der Thread vom laufenden Zustand in den beendeten Zustand.

3. Codebeispiel

Das Folgende ist ein einfaches Codebeispiel, das die Konvertierungsregeln zwischen Thread-Zuständen zeigt:

class MyThread extends Thread {
    
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println("线程执行完毕");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ThreadStateDemo {

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        System.out.println("线程创建后状态：" + thread.getState());

        thread.start();
        System.out.println("调用start()方法后状态：" + thread.getState());

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("等待500ms后状态：" + thread.getState());

        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("调用join()方法后状态：" + thread.getState());
    }
}

Führen Sie den obigen Code aus. Sie können die Ausgabe wie folgt sehen:

线程创建后状态：NEW
调用start()方法后状态：RUNNABLE
等待500ms后状态：RUNNABLE
线程执行完毕
调用join()方法后状态：TERMINATED

Der obige Code erstellt eine Vererbung Thread-Objekt MyThread aus der Thread-Klasse. Im Hauptthread können wir die Zustandsänderungen des Thread-Objekts in verschiedenen Phasen beobachten.

Durch ein tiefes Verständnis der fünf Zustände von Java-Threads und ihrer Konvertierungsregeln können wir die Prinzipien des Multithreadings besser verstehen und die Fähigkeit der gleichzeitigen Programmierung weiter verbessern. Gleichzeitig sind im eigentlichen Entwicklungsprozess auch die Beurteilung und Verarbeitung des Thread-Status sehr wichtig. Ich hoffe, dass dieser Artikel für alle hilfreich sein kann.

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der fünf Zustände von Java-Threads und Zustandsübergangsregeln. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!