java有哪些線程狀態

Java有哪些線程狀態

在Java中，線程是程序執行的最小單元，線程的狀態反映了線程在其生命周期中的不同階段。了解線程的狀態對于編寫高效、穩定的多線程程序至關重要。本文將詳細介紹Java中的線程狀態，包括每種狀態的定義、轉換條件以及相關的代碼示例。

1. 線程狀態概述

Java中的線程狀態由java.lang.Thread.State枚舉類定義，共有六種狀態：

1. NEW（新建）
2. RUNNABLE（可運行）
3. BLOCKED（阻塞）
4. WTING（等待）
5. TIMED_WTING（計時等待）
6. TERMINATED（終止）

這些狀態描述了線程在其生命周期中的不同階段。下面我們將逐一介紹每種狀態。

2. NEW（新建）

2.1 定義

當一個線程對象被創建但尚未啟動時，它處于NEW狀態。此時，線程還沒有開始執行，也沒有分配任何系統資源。

2.2 代碼示例

Thread thread = new Thread(() -> {
    System.out.println("Thread is running");
});
System.out.println("Thread state: " + thread.getState()); // 輸出: Thread state: NEW

2.3 狀態轉換

• NEW -> RUNNABLE：調用start()方法后，線程從NEW狀態轉換為RUNNABLE狀態。

3. RUNNABLE（可運行）

3.1 定義

當線程調用start()方法后，線程進入RUNNABLE狀態。此時，線程已經準備好運行，但可能還沒有真正開始執行，具體取決于操作系統的調度。

3.2 代碼示例

Thread thread = new Thread(() -> {
    System.out.println("Thread is running");
});
thread.start();
System.out.println("Thread state: " + thread.getState()); // 輸出: Thread state: RUNNABLE

3.3 狀態轉換

• RUNNABLE -> BLOCKED：線程嘗試獲取一個對象的鎖，但該鎖已被其他線程持有，線程將進入BLOCKED狀態。
• RUNNABLE -> WTING：線程調用了Object.wait()、Thread.join()或LockSupport.park()方法，線程將進入WTING狀態。
• RUNNABLE -> TIMED_WTING：線程調用了Thread.sleep(long millis)、Object.wait(long timeout)、Thread.join(long millis)或LockSupport.parkNanos(long nanos)等方法，線程將進入TIMED_WTING狀態。
• RUNNABLE -> TERMINATED：線程執行完畢，進入TERMINATED狀態。

4. BLOCKED（阻塞）

4.1 定義

當線程嘗試獲取一個對象的鎖，但該鎖已被其他線程持有時，線程將進入BLOCKED狀態。此時，線程無法繼續執行，直到鎖被釋放。

4.2 代碼示例

Object lock = new Object();

Thread thread1 = new Thread(() -> {
    synchronized (lock) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});

Thread thread2 = new Thread(() -> {
    synchronized (lock) {
        System.out.println("Thread2 acquired the lock");
    }
});

thread1.start();
thread2.start();

Thread.sleep(500); // 確保thread1先獲取鎖
System.out.println("Thread2 state: " + thread2.getState()); // 輸出: Thread2 state: BLOCKED

4.3 狀態轉換

• BLOCKED -> RUNNABLE：當鎖被釋放后，線程將重新進入RUNNABLE狀態，等待CPU調度。

5. WTING（等待）

5.1 定義

當線程調用了Object.wait()、Thread.join()或LockSupport.park()方法時，線程將進入WTING狀態。此時，線程將無限期地等待，直到其他線程喚醒它。

5.2 代碼示例

Object lock = new Object();

Thread thread = new Thread(() -> {
    synchronized (lock) {
        try {
            lock.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});

thread.start();
Thread.sleep(500); // 確保線程進入WTING狀態
System.out.println("Thread state: " + thread.getState()); // 輸出: Thread state: WTING

5.3 狀態轉換

• WTING -> RUNNABLE：當其他線程調用Object.notify()或Object.notifyAll()方法時，線程將被喚醒，重新進入RUNNABLE狀態。

6. TIMED_WTING（計時等待）

6.1 定義

當線程調用了Thread.sleep(long millis)、Object.wait(long timeout)、Thread.join(long millis)或LockSupport.parkNanos(long nanos)等方法時，線程將進入TIMED_WTING狀態。此時，線程將等待指定的時間，或者被其他線程喚醒。

6.2 代碼示例

Thread thread = new Thread(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});

thread.start();
Thread.sleep(500); // 確保線程進入TIMED_WTING狀態
System.out.println("Thread state: " + thread.getState()); // 輸出: Thread state: TIMED_WTING

6.3 狀態轉換

• TIMED_WTING -> RUNNABLE：當等待時間到期或被其他線程喚醒時，線程將重新進入RUNNABLE狀態。

7. TERMINATED（終止）

7.1 定義

當線程執行完畢或因為異常而終止時，線程將進入TERMINATED狀態。此時，線程的生命周期結束，無法再次啟動。

7.2 代碼示例

Thread thread = new Thread(() -> {
    System.out.println("Thread is running");
});

thread.start();
thread.join(); // 等待線程執行完畢
System.out.println("Thread state: " + thread.getState()); // 輸出: Thread state: TERMINATED

7.3 狀態轉換

• TERMINATED：線程一旦進入TERMINATED狀態，就無法再轉換到其他狀態。

8. 線程狀態轉換圖

為了更直觀地理解線程狀態的轉換，下面是一個線程狀態轉換圖：

NEW -> RUNNABLE -> BLOCKED
         |          |
         v          v
      WTING <-> TIMED_WTING
         |
         v
      TERMINATED

9. 總結

Java中的線程狀態是理解多線程編程的基礎。通過了解每種狀態的定義、轉換條件以及相關的代碼示例，我們可以更好地掌握線程的生命周期，從而編寫出高效、穩定的多線程程序。在實際開發中，合理管理線程狀態，避免死鎖、資源競爭等問題，是確保程序正確運行的關鍵。

10. 參考資料

• Java Thread States
• Java Concurrency in Practice
• Java多線程編程實戰指南

通過本文的詳細介紹，相信讀者對Java中的線程狀態有了更深入的理解。在實際開發中，合理管理線程狀態，避免死鎖、資源競爭等問題，是確保程序正確運行的關鍵。希望本文能幫助讀者在多線程編程中更加得心應手。