Java執行緒狀態及切換

一、什么是Java執行緒狀態

在Java程式中，用于描述Java執行緒的六種狀態：

• 新建（NEW）：當前執行緒，剛剛新建出來，尚未啟動，
• 運行（RUNNABLE）：當前執行緒，處于競爭CPU時間分片或已經獲得CPU時間片的狀態，
• 等待（WAITTING）：當前執行緒，處于休眠，不參與CPU時間片競爭的狀態，
• 定時等待（TIMED_WAITTING）：當前執行緒，處于定時休眠，暫時不參與CPU時間片競爭的狀態，
• 阻塞（BLOCKED）：當前執行緒，處于阻塞，不參與CPU時間片競爭的狀態，
• 終止（TERMINATED）：當前執行緒，處于最終停止的狀態，

新建狀態，只能進入運行狀態，而終止狀態無法再轉為其他狀態，

等待/定時等待與阻塞，差別就是后者需要一個事件信號（如其他執行緒放棄當前執行緒需要的排他鎖），才可以進行狀態切換，當然，強行關閉也是可以的，

Java執行緒的實作并不受JVM規范約束，故不同虛擬機的實作，往往不同，目前主流的HotSpot是將每個Java執行緒直接映射到一個作業系統的原生執行緒，從而由作業系統完成一系列的執行緒調度

二、哪里看Java執行緒狀態

查看Java執行緒狀態，主要存在三種方式：

• java.lang.Thread.State下可以直接看到Java的六種執行緒狀態
• Java運行時，程式內部可以通過Thread.getState()獲取目標執行緒狀態
• Java運行時，程式外部可以通過jstack等工具，查看執行緒狀態

有關jstack等工具等使用，后續會有博客，專門闡述，

三、什么時候變換Java執行緒狀態

Java執行緒狀態的切換嘛，不啰嗦，直接上圖，

這張圖涵蓋了Java執行緒狀態切換的各類方法，相較網上一些圖片，更為詳盡一些，
如果有所遺漏，可以告訴我，我會及時填補上，

四、誰在使用Java執行緒狀態

日常開發中，我們并不會直接與執行緒狀態進行互動，
我們往往直接使用JDK包裝好的工具，如JUC包下的各類工具等，

舉個栗子

執行緒池中的應用

位置：com.sun.corba.se.impl.orbutil.threadpool.ThreadPoolImpl#close

    // Note that this method should not return until AFTER all threads have died.
    public void close() throws IOException {

        // Copy to avoid concurrent modification problems.
        List<WorkerThread> copy = null;
        synchronized (workersLock) {
            copy = new ArrayList<>(workers);
        }

        for (WorkerThread wt : copy) {
            wt.close();
            while (wt.getState() != Thread.State.TERMINATED) {
                try {
                    wt.join();
                } catch (InterruptedException exc) {
                    wrapper.interruptedJoinCallWhileClosingThreadPool(exc, wt, this);
                }
            }
        }

        threadGroup = null;
    }

實際查看JDK后發現，JDK中其實也沒有辣么多的實體，并且大多數直接關聯執行緒狀態的，也是一些狀態查看的東東，
這在文章開頭就說，Java執行緒操作，是很底層的，甚至其實作都不包含在虛擬機規范中，
主流的HotSpot，也是直接將Java執行緒映射到系統執行緒，由系統進行一系列的執行緒調度處理，
所以，在JDK中，是直接對執行緒狀態進行處理的部分是很少的，

五、為什么需要執行緒狀態

1.為什么需要執行緒狀態這一概念

這個問題，可以從兩個角度來說明：生命周期與資源管理

• 一方面，執行緒狀態很好地刻畫了執行緒的整個生命周期，對生命周期中不同階段進行了有效劃分，
• 另一方面，資源是有限的，需求是無限的，所以需要將系統資源有意識地進行調度，合理利用比較優勢，追求帕累托最優，

實作后者的，就是利用執行緒在生命周期的不同階段這一天然屬性帶來的狀態刻畫，進行的分組，CPU調度只需要關注運行狀態的執行緒，而阻塞，等待等執行緒，都有著屬于自己的一套處理方式，最侄訓得資源（開發時對復雜性的應對，運行時對系統資源對消耗，應用者心智模型的成長等）的優化分配，

2.JDK中為什么需要定義Java執行緒狀態

前文有說到，Java中很少直接使用到執行緒狀態，那么為什么還要在JDK中定義Java的六種執行緒狀態呢？
一方面，通過資訊透明的方式，降低使用者使用時建立心智模型的成本，如，現在的我們可以通過列印日志，打斷點，快速了解Java的各個執行緒狀態，并清楚了解產生的原因，從而大大提高了我們對Java執行緒的認識，進而更為愉快地擁抱JUC包下諸如執行緒池等工具，
另一方面，通過可以直接應用的狀態列舉，我們可以很好地對現有工具進行二次開發等，如我們可以通過擴展AQS，并在其中添加執行緒狀態的校驗，從而得到定制化的執行緒同步工具，

六、如何使用執行緒狀態

使用的方式，我已經在上文說了：學習Java執行緒，定制執行緒相關工具開發，
這里給出一個有關執行緒學習的demo：

/**
 * @program: learning
 * @description: 用于確認執行緒狀態問題
 * @author: Jarry
 * @create: 2020-10-26 22:25
 **/
public class ThreadState {

    public static void main(String[] args) {
        threadStateTest();
//        threadStateTest2();
//        threadStateWithBlocked();
//        threadStateWithException();
//        threadStateWithSuspend();
    }

    /**
     * 實踐證明：Thread.suspend()與Thread.resume()不會改變執行緒狀態
     * 執行緒狀態該是Waiting，就Waiting，該Timed_Waiting就Timed_Waiting
     * Thread.suspend()與Thread.resume()只是掛起目標執行緒（并且不會釋放鎖資源）
     */
    private static void threadStateWithSuspend() {
        Thread thread1 = new Thread(() -> {
//            LockSupport.park();
            LockSupport.parkNanos(2000000000);
        });

        thread1.start();
        printThreadState(thread1);
        LockSupport.parkNanos(500000000);
        printThreadState(thread1);
        thread1.suspend();
        printThreadState(thread1);
        LockSupport.parkNanos(500000000);
        printThreadState(thread1);
        thread1.resume();
        LockSupport.parkNanos(500000000);
        printThreadState(thread1);

//        LockSupport.unpark(thread1);
    }

    /**
     * 展現執行緒阻塞狀態
     */
    private static void threadStateWithBlocked() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                synchronized (ThreadState.class) {
//                    LockSupport.parkNanos(2000000000);
                    LockSupport.park();
                }
            }
        };

        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);

        thread1.start();
        LockSupport.parkNanos(500000000);
        thread2.start();
        // 加上以下時間間隔，則結果：Runnable->Blocked
        // 推論：Thread.start()會將執行緒狀態設定為Runnable，然后在遇到sync的鎖，再切換為Blocked狀態
//        LockSupport.parkNanos(500000000);

        printThreadState(thread2);
        LockSupport.parkNanos(500000000);
        printThreadState(thread2);

        LockSupport.parkNanos(500000000);
        LockSupport.unpark(thread1);
        LockSupport.unpark(thread2);

    }

    /**
     * 由于底層實作機制的不同（相較于其他waiting的方法），無法直接進行Object.wait()，否則會拋出以下例外
     * @exception java.lang.IllegalMonitorStateException
     * object.wait()進行wait的方法，是直接對其wait_set進行操作
     */
    private static void threadStateWithException() {
        Thread thread1 = new Thread(() -> {
            try {
                ThreadState.class.wait(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        });

        thread1.start();
        LockSupport.parkNanos(1000000000);
        printThreadState(thread1);

    }

    /**
     * Object.wait()的使用
     */
    private static void threadStateTest3() {
        Thread thread1 = new Thread(() -> {
            synchronized (ThreadState.class) {
                try {
                    ThreadState.class.wait(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        thread1.start();
        LockSupport.parkNanos(1000000000);
        printThreadState(thread1);

    }

    /**
     * 確定LockSupport.parkNacos()是否可以生成Time_Waiting狀態
     */
    private static void threadStateTest2() {
        Thread thread1 = new Thread(() -> {
            LockSupport.parkNanos(2000000000);
        });

        thread1.start();
        printThreadState(thread1);
        LockSupport.parkNanos(1000000000);

        printThreadState(thread1);
    }

    /**
     * 查看到除Blocked以外的所有執行緒狀態
     */
    private static void threadStateTest() {
        Thread thread1 = new Thread(() -> {
            synchronized (ThreadState.class) {
                // Runnable
                printThreadState(Thread.currentThread());

                // 1.Thread.sleep(time)
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
                // 2.Object.wait(time)
//                try {
//                    ThreadState.class.wait(2000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                // 3.Thread.join(time)
//                try {
//                    Thread.currentThread().join(2000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                // 4.LockSupport.parkNanos(time);
//            LockSupport.parkNanos(2000000000);
                // 5.LockSupport.parkUntil(timeStamp);
//            LockSupport.parkUntil(System.currentTimeMillis()+2000);

                LockSupport.park();
            }

        });
        thread1.setName("test_thread");

        // New
        printThreadState(thread1);

        thread1.start();
        LockSupport.parkNanos(1000000000);
        // Timed_waiting
        printThreadState(thread1);

        LockSupport.parkNanos(2000000000);
        // Waiting
        printThreadState(thread1);

        LockSupport.unpark(thread1);

        LockSupport.parkNanos(1000000000);
        // Terminated
        printThreadState(thread1);


    }

    private static void printThreadState(Thread thread) {
        System.out.println("current Thread(" + thread.getName()+":" + thread.getId() + ") state:" + thread.getState());
    }

}

代碼中有一些細碎的知識點，就不在這里贅述了，感興趣的小伙伴，可以自己看看注釋，自行驗證，

七、擴展：系統狀態（三態&五態）

作業系統就包含行程管理，作業管理，檔案管理等，其中行程管理，就涉及系統狀態的三態模型與五態模型，
其中，三態模型包含以下三種狀態：

• 就緒狀態
• 運行狀態
• 阻塞狀態

而五態模型則包含以下五種狀態：

• 運行狀態
• 靜止就緒態
• 活躍就緒態
• 靜止阻塞態
• 活躍阻塞態

具體狀態切換等，可以看我之前寫的一篇博客：
系統架構設計師-作業系統

最后，愿與諸君共進步，

八、附錄

補充：WAITTING/TIMED_WAITTING與BLOCKED的區別

其實，我之前也挺糾結這個問題的，
當時的想法是WAITTING/TIMED_WAITTING是由JVM自己維持，而BLOCKED是由系統維持的，后面看到主流的HotSpot是將執行緒映射到系統原生執行緒的，所以這個想法大概率是錯誤的，
那么兩者區別是什么呢？
直到我在上文的示例代碼中，BLOCKED狀態的執行緒，在其他執行緒釋放其所需的鎖時，該執行緒是先轉為RUNNING狀態，再變為其他狀態，這引起我的注意，
最后在stackOverFlow的一篇文章（Difference between WAIT and BLOCKED thread states）中，看到這樣的解釋：

The important difference between the blocked and wait states is the impact on the scheduler. A thread in a blocked state is contending for a lock; that thread still counts as something the scheduler needs to service, possibly getting factored into the scheduler's decisions about how much time to give running threads (so that it can give the threads blocking on the lock a chance).
Once a thread is in the wait state the stress it puts on the system is minimized, and the scheduler doesn't have to worry about it. It goes dormant until it receives a notification. Except for the fact that it keeps an OS thread occupied it is entirely out of play.
This is why using notifyAll is less than ideal, it causes a bunch of threads that were previously happily dormant putting no load on the system to get woken up, where most of them will block until they can acquire the lock, find the condition they are waiting for is not true, and go back to waiting. It would be preferable to notify only those threads that have a chance of making progress.
(Using ReentrantLock instead of intrinsic locks allows you to have multiple conditions for one lock, so that you can make sure the notified thread is one that's waiting on a particular condition, avoiding the lost-notification bug in the case of a thread getting notified for something it can't act on.)

簡單說，就是CPU時間片不會考慮WAITTING/TIMED_WAITTING狀態，
但是，雖然BLOCKED狀態的執行緒無法獲得CPU時間片，但是系統調度時，依舊會考慮BLOCKED狀態的執行緒，將其置于調度計算中，

如果哪位小伙伴對這方面有了解，希望可以聊一聊，

參考

• JDK
• Java虛擬機規范
• 《系統架構設計師教程》
• 《深入理解Java虛擬機》
• 系統架構設計師-作業系統
• java中的interrupt()方法
• Lifecycle and States of a Thread in Java
• Difference between WAIT and BLOCKED thread states

標籤：Java

上一篇：java基礎基礎知識點總結

下一篇：JIRA、Confluence等產品明年2月停售本地化版本，將影響中國近90%的客戶！