2. 程式人生 > >java多執行緒狀態詳解

java多執行緒狀態詳解

阿新 • • 發佈：2019-01-23

java.lang.Thread類中有個內部列舉類State用來描述執行緒的各種狀態，具體如下

    public enum State {
        /**
         * 尚未啟動的執行緒的狀態。
         */
        NEW,

        /**
         * 可執行執行緒的執行緒狀態。處於可執行狀態的某一執行緒正在Java虛擬機器中執行，但它可能正在等待作業系統            * 中的其他資源，比如處理器。
         */
        RUNNABLE,

        /**
         * 受阻塞並且正在等待監視器鎖的某一執行緒的執行緒狀態。處於受阻塞狀態的某一執行緒正在等待監視器鎖，以          * 便進入一個同步程式碼塊/方法，或者在呼叫Object.wait之後再次進入同步程式碼塊/方法。
         */
 

        BLOCKED,

        /**
         * 某一等待執行緒的執行緒狀態。某一執行緒因為呼叫下列方法之一而處於等待狀態：
         * <ul> 
         *    <li>不帶超時值的Object.wait</li>
         *    <li>不帶超時值的Thread.join</li>
         *    <li>LockSupport.park<li>
         * </ul>
         * 處於等待狀態的執行緒正等待另一個執行緒執行特定操作。 例如，已經在某一物件上呼叫了Object.wait()的          * 執行緒正等待另一個執行緒在該物件上呼叫Object.notify()或Object.notifyAll()。已經呼叫了                * Thread.join()的執行緒正在等待指定執行緒終止。
         */
 

        WAITING,

        /**
         * 具有指定等待時間的某一等待執行緒的執行緒狀態。某一執行緒因為呼叫以下帶有指定正等待時間的方法之一而處         * 於定時等待狀態：
         * <ul>
         *    <li>Thread.sleep</li>
         *    <li>帶有超時值的 Object.wait</li>
         *    <li>帶有超時值的 Thread.join</li>
         *    <li>LockSupport.parkNanos</li>
         *    <li>LockSupport.parkUntil</li>
         * </ul>
         */
 

        TIMED_WAITING,

        /**
         * 已終止執行緒的執行緒狀態。執行緒已經結束執行。
         */
        TERMINATED;
    }

下面就用程式碼呈現各種執行緒狀態

  1. NEW狀態

    package cn.cjc.multithread;

public class MainTest {
   public static void main(String[] args) {
       Thread t = new Thread();
       System.out.println(t.getState());
   }
}

    輸出結果就是NEW

  2. RUNNABLE狀態

    package cn.cjc.multithread;

public class MainTest {
   public static void main(String[] args) {
       Thread t = new Thread();
       t.start();
       System.out.println(t.getState());
   }
}

    輸出結果就是RUNNABLE，不過這樣並不是每次都能打印出RUNNABLE，也有可能打印出TERMINATED，因為main執行緒和t執行緒是併發執行的，有可能在列印執行緒狀態時t執行緒已經結束運行了。為了總能打印出RUNNABLE，讓t執行緒無限執行下去，程式碼如下

    package cn.cjc.multithread;

public class MainTest {
   public static void main(String[] args) {
       Thread t = new Thread(new Runnable() {
           @Override
           public void run() {
               while (true) ;//無限迴圈
           }
       });
       t.start();
       System.out.println(t.getState());
   }
}

    還有一種檢視執行緒狀態的方法，就是用JVM命令檢視，對於上面的程式碼，程式會一直執行，所以可以用jstack命令dump出線程狀態，操作如下

    1）用jps命令檢視JVM程序的pid，可知pid=4069

    pid
    2）用jstack命令列印執行緒棧資訊，可以看到Thread-0的執行緒處於RUNNABLE狀態

    runnable

    需要注意的是執行緒狀態是RUNNABLE不代表該執行緒正在執行中，有可能該執行緒時間片用完，正在等待CPU，也就是處於就緒狀態。所以RUNNABLE有可能是正在執行中，也有可能是就緒狀態。

  3. BLOCKED狀態

    執行緒呼叫synchronized方法或者進入synchronized程式碼塊時，獲取不到監視器鎖而阻塞，則產生該狀態

    package cn.cjc.multithread;

public class MainTest {
   public static void main(String[] args) {
       final MainTest mainTest = new MainTest();
       new Thread(new Runnable() {
           @Override
           public void run() {
               mainTest.m1();
           }
       }, "thread-m1").start();

       new Thread(new Runnable() {
           @Override
           public void run() {
               mainTest.m2();
           }
       }, "thread-m2").start();
   }

   public synchronized void m1() {
       System.out.println("m1");
       while (true) ;
   }

   public synchronized void m2() {
       System.out.println("m2");
       while (true) ;
   }
}

    執行後用jstack命令檢視執行緒狀態發現thread-m1執行緒是RUNNABLE狀態，而thread-m2執行緒是BLOCKED (on object monitor)狀態，因為同步鎖一直被thread-m1持有，thread-m2在等待鎖

    blocked_1

    還有一種情況也會產生BLOCKED狀態，程式碼如下

    package cn.cjc.multithread;

public class MainTest {
   public static void main(String[] args) throws InterruptedException {
       final MainTest mainTest = new MainTest();
       new Thread(new Runnable() {
           @Override
           public void run() {
               mainTest.m1();
           }
       }, "thread-m1").start();

       new Thread(new Runnable() {
           @Override
           public void run() {
               mainTest.m2();
           }
       }, "thread-m2").start();

       Thread.sleep(3000);

       new Thread(new Runnable() {
           @Override
           public void run() {
               mainTest.m3();
           }
       }, "thread-m3").start();
   }

   public synchronized void m1() {
       System.out.println("m1---start");
       try {
           this.wait();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("m1---end");
       while (true) ;
   }

   public synchronized void m2() {
       System.out.println("m2---start");
       try {
           this.wait();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("m2---end");
       while (true) ;
   }

   public synchronized void m3() {
       System.out.println("m3");
       this.notifyAll();//注意不是this.notify()哦
   }
}

    執行後用jstack命令列印如下

    blocked_2

    發現thread-m1執行緒是BLOCKED (on object monitor)狀態，這和第一種情況不是一樣嗎？其實不一樣，看此處thread-m1執行緒棧的第一行有個in Object.wait()，而第一種情況thread-m2執行緒棧的第一行是waiting for monitor entry，有啥區別？

    第二種情況產生過程是這樣：m1執行緒先持有鎖，然後釋放鎖並等待被喚醒，緊接著m2執行緒持有鎖，然後釋放鎖並等待被喚醒，m3執行緒呼叫notifyAll方法喚醒了所有等待著的執行緒，這時候m2執行緒拿到鎖並一直持有，m1執行緒因為被喚醒了，但沒有拿到鎖，所以從WAITING狀態變成了BLOCKED狀態。

    第一種情況下執行緒BLOCKED，是在Entry Set裡面，第二種情況執行緒BLOCKED，是在Wait Set裡面。

    我要說還有第三種情況的BLOCKED，會不會被打？真有呢！就是呼叫帶超時時間的Object.wait且看程式碼

    package cn.cjc.multithread;

public class MainTest {
   public static void main(String[] args) {
       final MainTest mainTest = new MainTest();
       new Thread(new Runnable() {
           @Override
           public void run() {
               mainTest.m1();
           }
       }, "thread-m1").start();

       new Thread(new Runnable() {
           @Override
           public void run() {
               mainTest.m2();
           }
       }, "thread-m2").start();
   }

   public synchronized void m1() {
       System.out.println("m1---start");
       try {
           this.wait(30000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("m1---end");
       while (true) ;
   }

   public synchronized void m2() {
       System.out.println("m2---start");
       try {
           this.wait(30000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("m2---end");
       while (true) ;
   }
}

    執行起來後，30s內用jstack命令檢視執行緒m1和m2的狀態都是WAITING (on object monitor)，但是30s以後檢視執行緒狀態，如圖示

    blocked_3

    thread-m2執行緒處在BLOCKED狀態，但是阻塞原因第二情況是in Object.wait()，而這個是waiting for monitor entry，我以為會和第二種情況一樣（為什麼會不一樣呢？後面有時間再深入看看），納尼？這不是和第一種進入synchronized同步塊的情況一樣嗎？確實很像，但是從阻塞執行緒棧的第三行往下看就可以區分開來了。

  4. WAITING狀態

    WAITING狀態線上程棧中有兩種不同的體現，分別為WAITING (on object monitor)和WAITING (parking)。

    1）呼叫Object.wait()產生WAITING (on object monitor)狀態，程式碼如下

    package cn.cjc.multithread;

public class MainTest {
   public static void main(String[] args) {
       final MainTest mainTest = new MainTest();
       new Thread(new Runnable() {
           @Override
           public void run() {
               mainTest.m1();
           }
       }, "thread-m1").start();
   }

   public synchronized void m1() {
       System.out.println("m1---start");
       try {
           this.wait();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("m1---end");
   }
}

    執行後的執行緒棧如下

    waiting_1

    2）呼叫Thread.join產生WAITING (on object monitor)狀態，程式碼如下

    package cn.cjc.multithread;

public class MainTest {
   public static void main(String[] args) throws InterruptedException {
       Thread t = new Thread(new Runnable() {
           @Override
           public void run() {
               while (true) ;
           }
       });
       t.start();
       t.join();//等待t執行緒結束後再往下執行
       System.out.println("main---end");
   }
}

    執行後執行緒棧如下

    waiting_2

    3）呼叫java.util.concurrent.locks.Lock#lock方法會產生WAITING (parking)狀態，程式碼如下

    package cn.cjc.multithread;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MainTest {
   private Lock lock = new ReentrantLock();

   public static void main(String[] args) {
       final MainTest mainTest = new MainTest();
       new Thread(new Runnable() {
           @Override
           public void run() {
               mainTest.m1();
           }
       }, "thread-m1").start();

       new Thread(new Runnable() {
           @Override
           public void run() {
               mainTest.m2();
           }
       }, "thread-m2").start();
   }

   public void m1() {
       lock.lock();
       try {
           System.out.println("m1---start");
           while (true) ;
       } finally {
           lock.unlock();
           System.out.println("m1---end");
       }
   }

   public void m2() {
       lock.lock();
       try {
           System.out.println("m2---start");
           while (true) ;
       } finally {
           lock.unlock();
           System.out.println("m2---end");
       }
   }
}

    執行後的執行緒棧如下

    waiting_3

    可以發現thread-m1執行緒在執行中，而thread-m2執行緒沒有獲得鎖處於WAITING狀態，這個和進入synchronized方法或程式碼塊時沒有獲得鎖產生的狀態是完全不一樣的。

    另外java.util.concurrent.locks.Condition#await()方法也會產生WAITING (parking)狀態，java.util.concurrent.BlockingQueue#put和java.util.concurrent.BlockingQueue#take底層呼叫的就是此方法。其實它們底層呼叫的都是LockSupport.park方法。

  5. TIMED_WAITING狀態

    TIMED_WAITING狀態要細分的話，會有三種，分別是TIMED_WAITING (sleeping)、TIMED_WAITING (on object monitor)、TIMED_WAITING (parking)

    1）Thread.sleep方法會產生第一種狀態；

    2）帶超時時間的Object.wait和帶超時時間的Thread.join方法會產生第二種狀態；

    3）帶超時時間的lock.tryLock和帶超時時間的Condition.await方法會產生第三種狀態，帶超時時間的java.util.concurrent.BlockingQueue#offer和java.util.concurrent.BlockingQueue#poll的底層呼叫的就是帶超時時間的Condition.awaitNanos方法。

  6. TERMINATED狀態

    這個狀態最好理解，如程式碼

    package cn.cjc.multithread;

public class MainTest {
   public static void main(String[] args) throws InterruptedException {
       Thread t = new Thread();
       t.start();
       Thread.sleep(3000);
       System.out.println(t.getState());
   }
}

    輸出結果就是TERMINATED

相關推薦

java多執行緒狀態詳解

java.lang.Thread類中有個內部列舉類State用來描述執行緒的各種狀態，具體如下 public enum State { /** * 尚未啟

Java 多執行緒方法詳解

靜態方法 Thread Thread.currentThread() 該方法用於獲取當前執行緒物件，當我們用Runnable方式來實現run的時候，run中的this指向的不是執行緒物件，此時你要獲取

JAVA多執行緒synchronized詳解

Java語言的關鍵字，當它用來修飾一個方法或者一個程式碼塊的時候，能夠保證在同一時刻最多隻有一個執行緒執行該段程式碼。 當兩個併發執行緒訪問同一個物件object中的這個synchronized(this)同步程式碼塊時，一個時間內只能有一個執行緒得到執行。另一個執行緒必須等待當前執行緒執行完這個程

40個Java多執行緒問題詳解複習

1、多執行緒有什麼用？ 一個可能在很多人看來很扯淡的一個問題：我會用多執行緒就好了，還管它有什麼用？在我看來，這個回答更扯淡。所謂"知其然知其所以然"，"會用"只是"知其然"，"為什麼用"才是"知其所以然"，只有達到"知其然知其所以然"的程度才可以說是把一個知識點運用自如。OK，下面說說我對這個問題的看法：

java執行緒狀態詳解

執行緒狀態 執行緒狀態總共可分為五大狀態： 新建 可執行 執行 等待阻塞睡眠 死亡，如下圖所述： 1.新建（NEW）： 執行緒物件已經建立，但還沒呼叫start()方法。 2.可執行（RUNNABLE）： 當執行緒有資格執行，但還沒有獲得cpu資源。當start()方法呼叫後，執行緒先

Java多執行緒——多執行緒方法詳解

本系列文章是Java多執行緒的詳解介紹，對多執行緒還不熟悉的同學可以先去看一下我的這篇部落格Java基礎系列3：多執行緒超詳細總結，這篇部落格從巨集觀層面介紹了多執行緒的整體概況，接下來的幾篇文章是對多執行緒的深入剖析。   多執行緒的常用方法 1、currentThread()方法： 介紹：cur

《Exploring in UE4》多執行緒機制詳解[原理分析]

目錄 一．概述 二．"標準"多執行緒 三．AsyncTask系統 3.1 FQueuedThreadPool執行緒池 3.2 Asyntask與IQueuedWork 3.3 其他相關技術細節 四．TaskGraph系統 4.1 從Tick函式談起 4.2 T

java 多執行緒上傳解壓檔案

舉個公司專案開發遇到的一個簡單例子，使用者上傳壓縮檔案到伺服器後，要對該壓縮包進行兩個操作，一是將該壓縮包複製到指定目錄，一是將該壓縮包解壓到另一指定目錄，最終響應使用者提示檔案上傳成功。如果壓縮包很大的話，上傳後進行的複製和解壓功能也會佔用很長時間，使用者就會等待很長的

阻塞式和多執行緒 BIO 詳解 ServerSocket例項

1.什麼是IO流是一種抽象概念，它代表了資料的無結構化傳遞。按照流的方式進行輸入輸出，資料被當成無結構的位元組或字元序列。從流中取得資料的操作稱為讀取，而向流中新增資料的操作稱為寫入。用來進行輸入輸出操作的流就稱為IO流。換句話說，IO流就是以流的方式進行輸入輸出。用通俗的話

php多執行緒pthread詳解

**執行緒(thread)： 作業系統能夠進行運算排程的最小單元，包含在程序中，是程序的實際運算單位。 一條執行緒指的是程序中一個單一順序的控制流，一個程序中可以併發多個執行緒，每條

.NET多執行緒技術詳解（4） 執行緒優先順序

執行緒優先順序從高到低分為：Highest 、AboveNormal、Normal、BelowNormal、Lowest共5個等級。通過設定Thread類的ThreadPriority屬性（可讀寫屬性）來調整。 範例： 下面的程式碼示例說明了更改執行緒優先順序的結果。建立兩

.NET多執行緒技術詳解（2） 建立、終止執行緒

System.Threading 名稱空間提供支援多執行緒程式設計的類和介面，使您可以輕鬆地執行建立和啟動新執行緒，同步多個執行緒，掛起執行緒以及中止執行緒等任務。 Thread類有幾個至關重要的方法，描述如下：Start()：啟動執行緒；Sleep(int)：靜態方法，

socket accept()多執行緒連線 詳解

你也可以檢視我的其他同類文章，也會讓你有一定的收貨！ 在使用accept函式的時候，如果伺服器面向多個客戶的連線， 必須使用while迴圈，每次迴圈阻塞在accept函式，等待新的連線到來

iOS－GCD多執行緒程式設計詳解1

文明看博轉載是對自己的尊重也是對學者的鼓勵，歡迎討論 iOS－GCD多執行緒程式設計詳解 一.前言 前面的多執行緒程式設計中分別講到NSThread和NSOperation的多執行緒程式設計，本張主要是講述GCD的程式設計，GCD的多執行緒程式設計是基於BLock或者函式

Linux—POSIX多執行緒管理-詳解

還在編寫中..... 多執行緒開發在 Linux 平臺上已經有成熟的 Pthread 庫支援。其涉及的多執行緒開發的最基本概念主要包含三點：執行緒，互斥鎖，條件。其中，執行緒操作又分執行緒的建立，退出，等待 3 種。互斥鎖則包括 4 種操作，分別是建立，銷燬，加鎖和解鎖。條

C++11多執行緒——lock詳解

C++11提供了兩種管理鎖的類 std::lock_guard：與mutex RAII相關，方便執行緒對互斥量上鎖std::unique_lock:   與mutex RAII相關，方便執行緒對互斥量

.NET多執行緒技術詳解（1）

預設情況下，C# 程式具有一個執行緒。此執行緒執行程式中以Main方法開始和結束的程式碼。Main直接或間接執行的每一個命令都由預設執行緒（或主執行緒）執行，當Main返回時此執行緒也將終止。不過，可以建立輔助執行緒，以便與主執行緒一起並行執行程式碼。這些執行緒通常稱為“輔

MFC——多執行緒程式設計詳解

一、問題的提出      編寫一個耗時的單執行緒程式：      　　新建一個基於對話方塊的應用程式SingleThread，在主對話方塊IDD_SINGLETHREAD_DIALOG新增一個按鈕，ID為 IDC_SLEEP_SIX_SECOND，標題為“延時6秒”，新增按

程序、執行緒與多執行緒概念詳解

一、概述 在windows中，每一個開啟執行的應用程式或後臺程式，比如執行中的QQ、谷歌瀏覽器、網易雲音樂、資源管理器等都是一個程序。我們感覺這些程式是“同時”執行的，但實際上，一個處理器同一時刻只能執行一個程序，只是CPU在高速輪換執行讓我們有這樣的錯覺，我

Java Thread(執行緒)案例詳解sleep和wait的區別

使用Wait()方法輸出結果:【顯示輸出】 我們來大致分析一下此段程式碼，main()方法中例項化ThreadTest並啟動該執行緒，然後呼叫該執行緒的一個方法（secondMethod()），因為在主執行緒中呼叫方法，所以呼叫的普通方法secondMethod()）會先被執行（但並不是普通方法執行完畢該物件