【Java】執行緒的 6 種狀態

(•̀ω•́)y發表於2020-11-14
Java執行緒

一、執行緒狀態的列舉

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。

 

相關文章