【Java】線程的 6 種狀態

一、線程狀態的枚舉

Java的線程從創建到銷毀總共有6種狀態。這些狀態被定義在Thread類種的內部枚舉 State 中，分別如下：

1、NEW：初始狀態。

線程實例已創建，但未啟動。

// 實例創建后，初始狀態為 NEW
Thread thread = new Thread();

2、RUNNABLE：運行狀態。

線程正在JVM中執行或等待操作系統資源（如CPU），包含 Ready（就緒）狀態和 Running（運行中）狀態。

（1）Ready 狀態：該線程在可運行的狀態，但在此刻線程調度器並沒有選擇執行該線程。

（2）Running 狀態：此刻線程調度器選擇執行該線程，線程得到了CPU的時間片資源。

3、BLOCKED：阻塞狀態。

線程在等待獲取監視器鎖資源，以便進入 synchronized 標記的方法或者代碼塊。

4、WAITING：等待狀態。

當調用以下方法后，線程將進入等待狀態：

（1）Object.wait(); // 調用不帶超時參數的 wait() 方法。

（2）anotherThread.join(); // 調用另一個線程的不帶超時參數的 join() 方法。

（3）LockSupport.park(); // 無限期掛起當前線程。

5、TIMED_WAITING：超時等待狀態。

指定了超時時間的等待狀態。當線程調用了如下方法后，線程將進入超時等待狀態：

（1）Thread.sleep(long millis) 或 Thread.sleep(long millis, int nanos)

（2）Object.wait(long timeout) 或 Object.wait(long timeout, int nanos)

（3）anotherThread.join(long millis) 或 anotherThread.join(long millis, int nanos)

（4）LockSupport.parkNanos(Object blocker, long nanos) 或 LockSupport.parkUntil(Object blocker, long deadline)

可以看到，跟 WAITING 狀態相比，引起 TIMED_WAITING 狀態的方法，主要是多了超時參數。

6、TERMINATED：終止狀態。

線程執行完成或被中斷，將進入終止狀態。進入終止狀態后的線程，無法重啟啟動。

如果再次調用 start() 方法，將會拋出 IllegalThreadStateException 異常。

調用run() 方法也不會有任何效果，線程內部的 Runnable 對象也已經被釋放。

二、線程狀態的轉換

Java線程狀態的轉換過程，如下圖所示。

三、線程狀態的獲取

當前線程的狀態可以通過 Thread.currentThread().getState() 獲取。顯然，獲取自己的狀態，得到的肯定是運行狀態。

一個線程實例的狀態，可以通過 thread.getState()方法獲取。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            // running:RUNNABLE
            System.out.println("running:" + Thread.currentThread().getState());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // before start():NEW
        System.out.println("before start():" + thread.getState());
        thread.start();
        // 暫停一下主線程
        Thread.sleep(100);
        // 由於線程內sleep了1秒，此時將處於有限時間等待狀態
        // after start():TIMED_WAITING
        System.out.println("after start():" + thread.getState());
        // 等待線程結束
        thread.join();
        // thread state:TERMINATED
        System.out.println("thread state:" + thread.getState());
    }
}

 

測試Lock對應的線程狀態：

public class Main {
    private static final Lock LOCK = new ReentrantLock();
    private static volatile int value = 0;
​
    public static void main(String[] args) throws InterruptedException {
        Thread alice = new Thread(() -> testLock("Alice"));
        Thread bob = new Thread(() -> testLock("Bob"));
        // alice before start():NEW
        System.out.println("alice before start():" + alice.getState());
        alice.start();
        // 暫停一下主線程
        Thread.sleep(100);
        bob.start();
        Thread.sleep(100);
        // bob.getState():WAITING
        System.out.println("bob.getState():" + bob.getState());
        value = 1000;
    }
​
    static void testLock(String name) {
        // 注意：鎖住的是代碼塊，不是里面用到的變量、資源
        LOCK.lock();
        try {
            System.out.println("Lock block code, name=" + name);
            // 注意：這是非線程安全的操作
            value += 10;
            System.out.println("Before sleep(): name=" + name + ",value=" + value);
            Thread.sleep(1000);
            System.out.println("After sleep(): name=" + name + ",value=" + value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            LOCK.unlock();
        }
    }
}

由上面的例子可見，等待進入Lock.lock() 代碼塊的線程的狀態，是 WAITING 狀態，而不是 BLOCKED。

如果調用的是Lock.tryLock(long, TimeUnit) 方法，對應的狀態將是 TIMED_WAITING。