Eingehende Untersuchung verschiedener Zustände von Java-Threads und deren Auswirkungen auf die Programmausführung

Eingehende Untersuchung verschiedener Zustände von Java-Threads und ihrer Auswirkungen auf die Programmausführung

In Java ist ein Thread eine leichte Ausführungseinheit, die unabhängig in einem Programm ausgeführt werden und bestimmte Aufgaben ausführen kann. Der Status eines Threads beschreibt die verschiedenen Phasen der Thread-Ausführung. Das Verständnis des Status eines Threads ist für das Schreiben von Multithread-Programmen und die Optimierung der Programmleistung sehr wichtig. Dieser Artikel befasst sich mit verschiedenen Zuständen von Java-Threads und deren Auswirkungen auf die Programmausführung und stellt spezifische Codebeispiele bereit.

Zu den verschiedenen Zuständen von Java-Threads gehören: NEW (neu), RUNNABLE (ausführbar), BLOCKED (blockiert), WAITING (wartend), TIMED_WAITING (zeitgesteuertes Warten) und TERMINATED (beendet).

1. Neuer (NEU) Status: Wenn ein neuer Thread durch Erstellen einer Instanz der Thread-Klasse erstellt wird, befindet sich der Thread im neuen Status. Im neuen Zustand hat der Thread noch nicht mit der Ausführung von Code begonnen. Das Folgende ist ein Beispielcode zum Erstellen eines neuen Threads:

Thread thread = new Thread(() -> {
    System.out.println("Hello, World!");
});

2. Ausführbarer (RUNNABLE) Zustand: Wenn der Thread die start()-Methode aufruft, wechselt der Thread in den ausführbaren Zustand. In diesem Zustand wartet der Thread darauf, dass die CPU eine Zeitscheibe zuweist, um den Code in der run()-Methode auszuführen. Wenn sich mehrere Threads in einem ausführbaren Zustand befinden, weist das Betriebssystem diesen Threads gemäß der Planungsrichtlinie Zeitscheiben zu. Hier ist ein Beispielcode:

Thread thread = new Thread(() -> {
    System.out.println("Hello, World!");
});
thread.start();

3. Blockierter (BLOCKIERTER) Zustand: Wenn der Thread aus irgendeinem Grund nicht weiter ausgeführt werden kann, wechselt der Thread in den blockierten Zustand. Häufige Gründe sind das Warten auf Sperren, das Warten auf Eingabe und Ausgabe (E/A) usw. Im Blockierungszustand unterbricht der Thread die Ausführung, bis eine bestimmte Bedingung erfüllt ist, bevor er mit der Ausführung fortfahren kann. Hier ist ein Beispielcode, der das synchronisierte Schlüsselwort verwendet, um eine Thread-Synchronisierung zu erreichen:

public class MyRunnable implements Runnable {
    private Object lock = new Object();
    
    public void run() {
        synchronized(lock) {
            System.out.println("In synchronized block");
            // 一些代码
        }
    }
  
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
  
        thread1.start();
        thread2.start();
    }
}

Im obigen Code versuchen zwei Threads gleichzeitig, in den synchronisierten Block einzutreten. Da die Sperre gemeinsam genutzt wird, tritt der zweite Thread in die Blockierung ein Zustand bis Der erste Thread die Ausführung abschließt und die Sperre aufhebt.

4. Wartender (WAITING) Zustand: Der Thread wechselt unter den folgenden Umständen in den Wartezustand: Die Methode wait() wird aufgerufen, die Methode join() wird aufgerufen oder die Methode park() von LockSupport wird aufgerufen. Im Wartezustand führt der Thread keinen Code aktiv aus, bis er von anderen Threads aktiviert wird oder die Wartezeit abgelaufen ist. Das Folgende ist ein Beispielcode, der die Methode wait() verwendet:

public class MyThread extends Thread {
    public void run() {
        synchronized(this) {
            System.out.println("Waiting for next thread...");
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread resumed.");
        }
    }
  
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
  
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized(thread) {
            thread.notify();
        }
    }
}

Im obigen Code weckt der Hauptthread den Thread über die Methode notify() auf, nachdem der Thread in den Wartezustand eintritt.

5. Zeitgesteuerter Wartezustand (TIMED_WAITING): Der Thread wechselt unter den folgenden Umständen in den zeitgesteuerten Wartezustand: Die Methode „sleep()“ wird aufgerufen, die Methode „join()“ mit einem Timeout-Parameter wird aufgerufen und die Methode „wait()“ mit einem Der Timeout-Parameter wird als Methode bezeichnet und ruft die parkNanos()-Methode oder die parkUntil()-Methode von LockSupport auf. Im geplanten Wartezustand führt der Thread keinen Code aktiv aus und wird nach Erreichen der Wartezeit aktiviert. Das Folgende ist ein Beispielcode, der die Methode „sleep()“ verwendet:

public class MyThread extends Thread {
    public void run() {
        try {
            System.out.println("Thread sleeping...");
            Thread.sleep(2000);
            System.out.println("Thread woke up.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
  
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

Im obigen Code wechselt der Thread durch Aufrufen der Methode „sleep()“ in den geplanten Wartezustand und wartet 2 Sekunden, bevor er aktiviert wird.

6. TERMINATED-Status: Nachdem der Thread die Ausführung des Codes in der run()-Methode abgeschlossen hat, wechselt der Thread in den beendeten Status. Im beendeten Zustand wird der Thread nicht mehr ausgeführt.

Zusammenfassend hat der Status des Threads einen wichtigen Einfluss auf die Ausführung des Programms. Das Verständnis der verschiedenen Zustände und ihrer Bedeutung ist entscheidend für das Schreiben effizienter Multithread-Programme.

Referenzmaterialien:

• Offizielle Oracle-Dokumentation – Java-Thread-Status: https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.State.html
• Java-Multithreading-Einführung Tutorial:https://www.journaldev.com/1162/java-thread-tutorial

Das obige ist der detaillierte Inhalt vonEingehende Untersuchung verschiedener Zustände von Java-Threads und deren Auswirkungen auf die Programmausführung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!