Was sind die 6 Zustände und Lebenszyklen von Java-Threads?

1. Thread-Status (Lebenszyklus)

Ein Thread kann zu einem bestimmten Zeitpunkt nur in einem Status sein.

Threads können die folgenden 6 Zustände haben:

• Neu (neu erstellt): nicht gestarteter Thread;

• Ausführbarer Thread, der auf Betriebssystemressourcen warten muss;

• Blockiert: a Thread blockiert, während auf die Monitorsperre gewartet wird;

• Warten: Warten auf den Aktivierungsstatus, Warten auf unbestimmte Zeit, bis ein anderer Thread aktiviert wird; Vorgang innerhalb der angegebenen Wartezeit;

• Terminiert (beendet): ein Thread, der beendet wurde.

• Um den aktuellen Status eines Threads zu ermitteln, können Sie die Methode getState aufrufen.

2. Vorgangs-Thread-Status

2.1. Neuer Erstellungsstatus (NEU)

ist der Status des Threads, der nach Abschluss der Instanziierung des Threads nicht gestartet wurde.

Threads können auf drei Arten erstellt werden, die die Thread -Klasse run () methode adimplement Die Runnable -Schnittstelle eiternde.

Das direkte Instanziieren des von der Thread-Klasse erstellten Threads ohne Überschreiben der run()- oder call()-Methode hat keine praktische Bedeutung.

Nur in der Callable-Methode erstellte Threads können den Rückgabewert des Threads erhalten.

2.2. Ausführbarer Zustand (RUNNABLE)

Dieser Zustand bezieht sich auf den Zustand, der eingegeben wird, nachdem der Thread das Objekt instanziiert und die start()-Methode aufgerufen hat. Der Thread befindet sich in einem ausführbaren Zustand und wenn Ressourcen wie ein Prozessor vorhanden sind, kann das Programm ausgeführt werden.

Dieser Zustand umfasst zwei Schritte auf

Betriebssystemebene

: Thread bereit und Thread läuft, aber im Java-Thread-Zustand werden diese beiden Schritte zusammen als Runnable (ausführbarer) Zustand bezeichnet.

• Wenn ein Thread vom Bereitschaftsstatus in den Ausführungsstatus wechselt, besteht der entscheidende Punkt darin, festzustellen, ob Ihr Thread die CPU-Ressource (CPU-Zeitscheibe) beansprucht hat. Wer auch immer sie erfasst, wird sie ausführen. Wenn dies nicht der Fall ist, warten Sie . Da die CPU-Zeitscheibe (Ausführungszeit) sehr kurz ist, etwa zehn Millisekunden, ist die Zeit für den Thread-Wechsel sehr kurz und die Zeit für den Übergang vom Bereitschaftszustand in den laufenden Zustand ist ebenfalls sehr kurz Entwicklungsänderungen, daher werden beide in Java als Ganzes betrachtet, wobei der Schwerpunkt darauf liegt, ob der Thread ausgeführt werden kann, und ihn von anderen Zuständen unterscheidet, was die Entwicklung von Threads weiter vereinfacht. Wenn Ihr Programm längere Zeit ausgeführt werden muss (z. B. beim Schreiben einer Endlosschleife) und die Ausführung nicht innerhalb einer CPU-Zeitscheibe abgeschlossen wird, muss Ihr Thread die nächste CPU-Zeitscheibe abrufen Es führt weiterhin das Programm aus. Wenn es nicht erfasst wurde, kann es mit der Ausführung des Programms fortfahren. Dann müssen Sie mit dem Abrufen fortfahren, bis die Programmausführung im Thread abgeschlossen ist.
  Tatsächlich sollten Sie dieses Szenario schon einmal gesehen haben. Wenn beispielsweise mehrere Threads dasselbe Programm ausführen und Protokolle in derselben Datei drucken, werden die Protokolle verschiedener Threads gemischt, was der Fehlerbehebung nicht förderlich ist. Übliche Methoden zur Lösung dieses Problems sind: Erstens das Protokoll in verschiedene Dateien in verschiedenen Threads drucken; zweitens die Protokollinformationen in einem Zeichenfolgenobjekt speichern und die Protokollinformationen am Ende des Programms auf einmal in die Datei drucken. Die zweite Methode besteht darin, eine Zeitscheibe der CPU zu verwenden, um den Druck der Protokollinformationen abzuschließen.
• Hinweis: Das Programm kann die start()-Methode nur für Threads im neu erstellten Zustand aufrufen. Rufen Sie die start()-Methode nicht für Threads im

  nicht neu erstellten Zustand

  auf. Dies führt zu einer IllegalThreadStateException-Ausnahme.
• 2.3. BLOCKIERT
  Der Thread
wartet auf

Monitorsperre

und ist gesperrt. Ein Thread hat die Sperre erworben, sie jedoch nicht freigegeben. Andere Threads haben die Sperre ebenfalls erworben, stellten jedoch fest, dass sie die Sperre nicht erhalten konnten, und traten in den blockierten Zustand ein.

Der blockierte Zustand besteht nur bei gleichzeitigem Zugriff durch mehrere Threads und unterscheidet sich von den beiden letztgenannten Blockierungsarten, die dadurch verursacht werden, dass der Thread selbst in „Warten“ wechselt. ?

2.4. Warten auf den Weckzustand (WARTEN)

Der gesamte Prozess ist wie folgt: Der Thread erhält zunächst die Objektsperre in der Synchronisationsmethode eines Objekts. Wenn die Wartemethode ausgeführt wird, gibt der Thread die Objektsperre frei und der Thread wird in den Wartemodus versetzt Status dieses Objekts. Warten Sie, bis ein anderer Thread die Sperre desselben Objekts erhält, und aktivieren Sie dann den Thread in der Objektwarteschlange über die Methode notify() oder notifyAll().

Aus dem gesamten Prozess können wir erkennen, dass die Methoden wait (), notify () und notifyAll () die Sperre erhalten müssen, bevor der Thread weiter ausgeführt werden kann. Daher müssen diese drei Methoden im synchronisierten Codeblock platziert werden /method Ausführen, andernfalls wird eine Ausnahme gemeldet: java.lang.IllegalMonitorStateException.

在同步代码块中，线程进入WAITING 状态时，锁会被释放，不会导致该线程阻塞。反过来想下，如果锁没释放，那其他线程就没办法获取锁，也就没办法唤醒它。

进入状态

• object.wait()

• thread.join()

• LockSupport.park()

退出状态

• object.notify()

• object.notifyall()

• LockSupport.unpark()

2.5.计时等待状态（TIMED_WAITING）

一般是计时结束就会自动唤醒线程继续执行后面的程序，对于Object.wait(long) 方法还可以主动通知唤醒。

注意：Thread类下的sleep() 方法可以放在任意地方执行；而wait(long) 方法和wait() 方法一样，需要放在同步代码块/方法中执行，否则报异常：java.lang.IllegalMonitorStateException。

进入状态

• Thread.sleep(long)

• Object.wait(long)

• Thread.join(long)

• LockSupport.parkNanos(long)

• LockSupport.parkNanos(Object blocker, long nanos)

• LockSupport.parkUntil(long)

• LockSupport.parkUntil(Object blocker, long deadline)

注：blocker 参数为负责此线程驻留的同步对象。

退出状态

• 计时结束

• LockSupport.unpark(Thread)

• object.notify()

• object.notifyall()

2.6.终止（TERMINATED）

线程执行结束

• run()/call() 执行完成

• stop()线程

• 错误或异常>>意外死亡

stop() 方法已弃用。

3.查看线程的6种状态

通过一个简单的例子来查看线程出现的6种状态。

案例

public class Demo3 {
    private static Object object ="obj";
    
    public static void main(String[] args) throws InterruptedException {

        Thread thread0 = new Thread(() -> {
            try {
                // 被阻塞状态（BLOCKED）
                synchronized (object){
                    System.out.println("thread0 进入：等待唤醒状态（WAITING）");
                    object.wait();
                    System.out.println("thread0 被解除完成：等待唤醒状态（WAITING）");
                }
                System.out.println("thread0 "+Thread.currentThread().getState());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // 新创建状态（NEW）
        System.out.println(thread0.getName()+"："+thread0.getState());

        Thread thread1 = new Thread(() -> {
            try {
                System.out.println("thread1 进入：计时等待状态（TIMED_WAITING）");
                Thread.sleep(2);
                System.out.println("thread1 出来：计时等待状态（TIMED_WAITING）");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 被阻塞状态（BLOCKED）
            synchronized (object){
                System.out.println("thread1 解除：等待唤醒状态（WAITING）");
                object.notify();
                System.out.println("thread1 解除完成：等待唤醒状态（WAITING）");
            }
            System.out.println("thread1 "+Thread.currentThread().getState());
        });
        // 新创建状态（NEW）
        System.out.println(thread1.getName()+"："+thread1.getState());

        printState(thread0);
        printState(thread1);

        // 可运行状态（RUNNABLE）
        thread0.start();
        // 可运行状态（RUNNABLE）
        thread1.start();

    }
    
    
    // 使用独立线程来打印线程状态
    private static void printState(Thread thread) {
        new Thread(()->{
            while (true){
                System.out.println(thread.getName()+"："+thread.getState());
                if (thread.getState().equals(Thread.State.TERMINATED)){
                    System.out.println(thread.getName()+"："+thread.getState());
                    break;
                }
            }
        }).start();
    }
}

执行结果：简化后的输出结果

Thread-0：NEW
Thread-1：NEW
Thread-0：RUNNABLE
Thread-1：RUNNABLE
thread0 进入：等待唤醒状态（WAITING）
Thread-1：BLOCKED
thread1 进入：计时等待状态（TIMED_WAITING）
Thread-0：BLOCKED
Thread-0：WAITING
……
Thread-0：WAITING
Thread-1：BLOCKED
Thread-1：TIMED_WAITING
……
Thread-1：TIMED_WAITING
Thread-1：BLOCKED
……
Thread-1：BLOCKED
Thread-0：WAITING
……
Thread-0：WAITING
thread1 出来：计时等待状态（TIMED_WAITING）
Thread-0：WAITING
Thread-1：BLOCKED
thread1 解除：等待唤醒状态（WAITING）
Thread-1：BLOCKED
Thread-0：WAITING
Thread-0：BLOCKED
thread1 解除完成：等待唤醒状态（WAITING）
Thread-1：BLOCKED
thread1 RUNNABLE
Thread-0：BLOCKED
Thread-1：TERMINATED
thread0 被解除完成：等待唤醒状态（WAITING）
Thread-0：BLOCKED
thread0 RUNNABLE
Thread-0：TERMINATED

最终的执行结果如图。

注意：因为案例中使用了独立线程来打印不同线程的状态，会出现状态打印稍微延迟的情况。

Das obige ist der detaillierte Inhalt vonWas sind die 6 Zustände und Lebenszyklen von Java-Threads?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!