這么理解線程生命周期，是不是很簡單？
為什么要了解線程的生命周期？
之前寫過 Spring Bean 生命周期三部曲：
有朋友留言說：“了解了它們的生命周期后，使用 Spring Bean 好比看到它們的行動軌跡，現在使用就一點都不慌了”。我和他一樣，了解事物的生命周期目的很簡單，唯【不慌】也
Java 并發系列 已經寫了很多，從來還沒提起過那個它【Java線程生命周期】。有了前序理論圖文的鋪墊，在走進源碼世界之前，談論它的時機恰好到了。因為，編寫并發程序的核心之一就是正確的擺弄線程狀態
線程生命周期的幾種狀態
剛接觸線程生命周期時，我總是記不住，也理解不了他們的狀態，可以說是比較混亂，更別說它們之間是如何進行狀態轉換的了。原因是我把操作系統通用線程狀態和編程語言封裝后的線程狀態 概念混淆在一起了
操作系統通用線程狀態
個人覺得通用線程狀態更符合我們的思考習慣。其狀態總共有 5 種 （如下圖）。對于經常寫并發程序的同學來說，其嘴里經常念的都是操作系統中的這些通用線程狀態，且看
除去生【初始狀態】死【終止狀態】，其實只是三種狀態的各種轉換，聽到這句話是不是心情放松了很多呢？
為了更好的說明通用線程狀態和 Java 語言中的線程狀態，這里還是先對前者進行簡短的說明
初始狀態
線程已被創建，但是還不被允許分配CPU執行。注意，這個被創建其實是屬于編程語言層面的，實際在操作系統里，真正的線程還沒被創建， 比如 Java 語言中的 new Thread()。
可運行狀態
線程可以分配CPU執行，這時，操作系統中線程已經被創建成功了
運行狀態
操作系統會為處在可運行狀態的線程分配CPU時間片，被 CPU 臨幸后，處在可運行狀態的線程就會變為運行狀態
休眠狀態
如果處在運行狀態的線程調用某個阻塞的API或等待某個事件條件可用，那么線程就會轉換到休眠狀態，注意：此時線程會釋放CPU使用權，休眠的線程永遠沒有機會獲得CPU使用權，只有當等待事件出現后，線程會從休眠狀態轉換到可運行狀態
終止狀態
線程執行完或者出現異常 (被interrupt那種不算的哈，后續會說)就會進入終止狀態，正式走到生命的盡頭，沒有起死回生的機會
接下來就來看看你熟悉又陌生，面試又經常被問到的Java 線程生命周期吧
Java語言線程狀態
在 Thread 的源碼中，定義了一個枚舉類 State，里面清晰明了的寫了Java語言中線程的6種狀態：
- NEW
- RUNNABLE
- BLOCKED
- WAITING
- TIMED_WAITING
- TERMINATED
這里要做一個小調查了，你有查看過這個類和讀過其注釋說明嗎？（歡迎留言腳印哦）
耳邊響起五環之歌，Java中線程狀態竟然比通用線程狀態的 5 種多1種，變成了 6 種。這個看似復雜，其實并不是你想的那樣，Java在通用線程狀態的基礎上，有裁剪，也有豐富，整體來說是少一種。再來看個圖，注意顏色區分哦
Java 語言中
- 將通用線程狀態的可運行狀態和運行狀態合并為 Runnable，
- 將休眠狀態細分為三種 (BLOCKED/WAITING/TIMED_WAITING); 反過來理解這句話，就是這三種狀態在操作系統的眼中都是休眠狀態，同樣不會獲得CPU使用權
看上圖右側【Java語言中的線程狀態】，進一步簡潔的說，除去線程生死，我們只要玩轉 RUNNABLE 和休眠狀態的轉換就可以了，編寫并發程序也多數是這兩種狀態的轉換。所以我們需要了解，有哪些時機，會觸發這些狀態轉換
遠看看輪廓， 近看看細節。我們將上面Java語言中的圖進行細化，將觸發的節點放到圖中 (這看似復雜的圖，其實三句話就能分解的，所以別慌)，且看：
RUNNABLE與BLOCKED狀態轉換
當且僅有（just only）一種情況會從 RUNNABLE 狀態進入到 BLOCKED 狀態，就是線程在等待 synchronized 內置隱式鎖；如果等待的線程獲取到了 synchronized 內置隱式鎖，也就會從 BLOCKED 狀態變為 RUNNABLE 狀態了
注意：
上面提到，以操作系統通用狀態來看，線程調用阻塞式 API，會變為休眠狀態（釋放CPU使用權），但在JVM層面，Java線程狀態不會發生變化，也就是說Java線程的狀態依舊會保持在 RUNNABLE 狀態。JVM并不關心操作系統調度的狀態。在JVM看來，等待CPU使用權（操作系統里是處在可執行狀態）與等待I/O（操作系統是處在休眠狀態），都是等待某個資源，所以都歸入了RUNNABLE 狀態
—— 摘自《Java并發編程實戰》
RUNNABLE與WAITING狀態轉換
調用不帶時間參數的等待API，就會從RUNNABLE狀態進入到WAITING狀態；當被喚醒就會從WAITING進入RUNNABLE狀態
RUNNABLE與 TIMED-WAITING 狀態轉換
調用帶時間參數的等待API，自然就從 RUNNABLE 狀態進入 TIMED-WAITING 狀態；當被喚醒或超時時間到就會從TIMED_WAITING進入RUNNABLE狀態
看圖中的轉換 API 挺多的，其實不用擔心，后續分析源碼章節，自然就會記住的，現在有個印象以及知道狀態轉換的節點就好了
相信到這里，你看Java線程生命周期的眼神就沒那么迷惑了，重點就是RUNNABLE與休眠狀態的切換，接下來我們看一看，如何查看線程中的狀態，以及具體的代碼觸發點
如何查看線程處在什么狀態
程序中調用 getState() 方法
Thread 類中同樣存在 getState() 方法用于查看當前線程狀態，該方法就是返回上面提到的枚舉類 State
NEW
就是上面提到， 編程語言中特有的，通過繼承 Thread 或實現 Runnable 接口定義線程后，這時的狀態都是 NEW
- Thread thread = new Thread(() -> {});
- System.out.println(thread.getState());
RUNNABLE
調用了 start() 方法之后，線程就處在 RUNNABLE 狀態了
- Thread thread = new Thread(() -> {});
- thread.start();
- //Thread.sleep(1000);
- System.out.println(thread.getState());
BLOCKED
等待 synchronized 內置鎖，就會處在 BLOCKED 狀態
- public class ThreadStateTest {
- public static void main(String[] args) throws InterruptedException {
- Thread t1 = new Thread(new DemoThreadB());
- Thread t2 = new Thread(new DemoThreadB());
- t1.start();
- t2.start();
- Thread.sleep(1000);
- System.out.println((t2.getState()));
- System.exit(0);
- }
- }
- class DemoThreadB implements Runnable {
- @Override
- public void run() {
- commonResource();
- }
- public static synchronized void commonResource() {
- while(true) {
- }
- }
- }
WAITING
調用線程的 join() 等方法，從 RUNNABLE 變為 WAITING 狀態
- public static void main(String[] args) throws InterruptedException {
- Thread main = Thread.currentThread();
- Thread thread2 = new Thread(() -> {
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- Thread.currentThread().interrupt();
- e.printStackTrace();
- }
- System.out.println(main.getState());
- });
- thread2.start();
- thread2.join();
- }
TIMED-WAITING
調用了 sleep(long) 等方法，線程從 RUNNABLE 變為 TIMED-WAITING 狀態
- public static void main(String[] args) throws InterruptedException {
- Thread thread3 = new Thread(() -> {
- try {
- Thread.sleep(3000);
- } catch (InterruptedException e) {
- // 為什么要調用interrupt方法？
- Thread.currentThread().interrupt();
- e.printStackTrace();
- }
- });
- thread3.start();
- Thread.sleep(1000);
- System.out.println(thread3.getState());
- }
TERMINATED
線程執行完自然就到了 TERMINATED 狀態了
- Thread thread = new Thread(() -> {});
- thread.start();
- Thread.sleep(1000);
- System.out.println(thread.getState());
以上是程序中查看線程，自己寫寫測試看看狀態還好，現實中的程序怎么可能允許你加這么多無用代碼，所以，翠花，上酸菜（jstack）
jstack 命令查看
相信你聽說過這玩意，jstack 命令就比較強大了，不僅能查看線程當前狀態，還能看調用棧，鎖等線程棧信息
大家可以隨意寫一些程序，這里我用了上面 WAITING 狀態的代碼, 修改睡眠時間 Thread.sleep(100000)，然后在終端按照下圖標示依次執行下圖命令
更多功能還請大家自行查看，后續會單獨寫文章來教大家如何使用jstack查看線程棧信息
Arthas
這個利器，無須多言吧，線上找茬監控沒毛病，希望你可以靈活使用這個工具，攻克疑難雜癥
查看線程棧詳細信息，非常方便：https://alibaba.github.io/art...
相信你已經和Arthas確認了眼神
關于線程生命周期狀態整體就算說完了，編寫并發程序時多問一問自己：
調用某個API會將你的線程置為甚么狀態？
多問自己幾次，自然就記住上面的圖了
靈魂追問
- 為什么調用 Thread.sleep, catch異常后，調用了Thread.currentThread().interrupt();
- 進入 BLOCKED只有一種情況，就是等待 synchronized 監視器鎖，那調用 JUC 中的 Lock.lock() 方法，如果某個線程等待這個鎖，這個線程狀態是什么呢？為什么？
- public class ThreadStateTest {
- public static void main(String[] args) throws InterruptedException {
- TestLock testLock = new TestLock();
- Thread thread2 = new Thread(() -> {
- testLock.myTestLock();
- }, "thread2");
- Thread thread1 = new Thread(() -> {
- testLock.myTestLock();
- }, "thread1");
- thread1.start();
- Thread.sleep(1000);
- thread2.start();
- Thread.sleep(1000);
- System.out.println("****" + (thread2.getState()));
- Thread.sleep(20000);
- }
- }
- @Slf4j
- class TestLock{
- private final Lock lock = new ReentrantLock();
- public void myTestLock(){
- lock.lock();
- try{
- Thread.sleep(10000);
- log.info("testLock status");
- } catch (InterruptedException e) {
- log.error(e.getMessage());
- } finally {
- lock.unlock();
- }
- }
- }
3. synchronized 和 Lock 有什么區別？
參考
感謝前輩們總結的精華，自己所寫的并發系列好多都參考了以下資料
- Java 并發編程實戰
- Java 并發編程之美
- 碼出高效
- Java 并發編程的藝術
- ......
我這面也在逐步總結常見的并發面試問題（總結ing......）答案整理好后會通知大家，請持續關注
