溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本篇內容主要講解“總結Thread線程，狀態轉換、方法使用、原理分析”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“總結Thread線程，狀態轉換、方法使用、原理分析”吧!
考不常用的、考你不會的、考你忽略的，才是考試！
大部分考試考的，基本都是不怎么用的。例外的咱們不說???? 就像你做程序開發，尤其在RPC+MQ+分庫分表，其實很難出現讓你用一個機器實例編寫多線程壓榨CPU性能。很多時候是扔出一個MQ，異步消費了。如果沒有資源競爭，例如庫表秒殺，那么其實你確實很難接觸多并發編程以及鎖的使用。
但！凡有例外，比如你需要開發一個數據庫路由中間件，那么就肯定會出現在一臺應用實例上分配數據庫資源池的情況，如果出現競爭就要合理分配資源。如此，類似這樣的中間件開發，就會涉及到一些更核心底層的技術的應用。
所以，有時候不是沒用，而是你沒有用。
謝飛機，小記！ 線程我玩定了，面試也攔不住我，我說的！
「謝飛機」：嘿，你好哇，我是謝飛機！
「面試官」：好，今天電話面試，你準備好了？
「謝飛機」：準備好了，嘿嘿！
「面試官」：嗯，我看你簡歷里寫了不少線程的東西，看來了解的不錯。問你一個線程吧那就，線程之間狀態是怎么轉換的？
「謝飛機」：扒拉扒拉，扒拉扒拉！
「面試官」：嗯，還不錯。那 yield 方法是怎么使用的。
「謝飛機」：嗯！好像是讓出CPU。具體的沒怎么用過！
「面試官」：做做測試，驗證下，下次問你。
Java 的線程狀態描述在枚舉類 java.lang.Thread.State 中，共包括如下五種狀態：
public enum State {
NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED;
}這五種狀態描述了一個線程的生命周期，其實這種狀態碼的定義在我們日常的業務開發中，也經常出現。比如：一個活動的提交、審核、拒絕、修改、通過、運行、關閉等，是類似的。那么線程的狀態是通過下圖的方式進行流轉的，如圖 20-1
New：新創建的一個線程，處于等待狀態。Runnable：可運行狀態，并不是已經運行，具體的線程調度各操作系統決定。在 Runnable 中包含了
Ready、
Running 兩個狀態，當線程調用了 start() 方法后，線程則處于就緒 Ready 狀態，等待操作系統分配 CPU 時間片，分配后則進入 Running 運行狀態。此外當調用 yield() 方法后，只是
謙讓的允許當前線程讓出CPU，但具體讓不讓不一定，由操作系統決定。如果讓了，那么當前線程則會處于 Ready 狀態繼續競爭CPU，直至執行。Timed_waiting：指定時間內讓出CPU資源，此時線程不會被執行，也不會被系統調度，直到等待時間到期后才會被執行。下列方法都可以觸發：
Thread.sleep、
Object.wait、
Thread.join、
LockSupport.parkNanos、
LockSupport.parkUntil。Wating：可被喚醒的等待狀態，此時線程不會被執行也不會被系統調度。此狀態可以通過 synchronized 獲得鎖，調用 wait 方法進入等待狀態。最后通過 notify、notifyall 喚醒。下列方法都可以觸發：
Object.wait、
Thread.join、
LockSupport.park。Blocked：當發生鎖競爭狀態下，沒有獲得鎖的線程會處于掛起狀態。例如 synchronized 鎖，先獲得的先執行，沒有獲得的進入阻塞狀態。Terminated：這個是終止狀態，從 New 到 Terminated 是不可逆的。一般是程序流程正常結束或者發生了異常。這里參考枚舉State 類的英文注釋了解了每一個狀態碼的含義，接下來我們去嘗試操作線程方法，把這些狀態體現出來。
Thread thread = new Thread(() -> {
});
System.out.println(thread.getState());
// NEW
Thread thread = new Thread(() -> {
});
// 啟動
thread.start();
System.out.println(thread.getState());
// RUNNABLE
start()，就會進入 RUNNABLE 狀態。但此時并不一定在執行，而是說這個線程已經就緒，可以競爭 CPU 資源。 Object obj = new Object();
new Thread(() -> {
synchronized (obj) {
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
Thread thread = new Thread(() -> {
synchronized (obj) {
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.start();
while (true) {
Thread.sleep(1000);
System.out.println(thread.getState());
}
// BLOCKED
// BLOCKED
// BLOCKED
BLOCKED Object obj = new Object();
Thread thread = new Thread(() -> {
synchronized (obj) {
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.start();
while (true) {
Thread.sleep(1000);
System.out.println(thread.getState());
}
// WAITING
// WAITING
// WAITING
wait 方法，又沒有被 notify 就會進入
WAITING 狀態。Thread.join 源碼中也是調用的 wait 方法，所以也會讓線程進入等待狀態。 Object obj = new Object();
Thread thread = new Thread(() -> {
synchronized (obj) {
try {
Thread.sleep(100000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.start();
while (true) {
Thread.sleep(1000);
System.out.println(thread.getState());
}
// TIMED_WAITING
// TIMED_WAITING
// TIMED_WAITING
Thread.sleep(100000); 就可以了。Thread thread = new Thread(() -> {
});
thread.start();
System.out.println(thread.getState());
System.out.println(thread.getState());
System.out.println(thread.getState());
// RUNNABLE
// TERMINATED
// TERMINATED
TERMINATED 狀態。一般情況下 Thread 中最常用的方法就是 start 啟動，除此之外一些其他方法可能在平常的開發中用的不多，但這些方法在一些框架中卻經常出現。因此只了解它們的概念，但是卻缺少一些實例來參考！ 接下來我們就來做一些案例來驗證這些方法，包括：yield、wait、notify、join。
yield 方法讓出CPU，但不一定，一定讓出！。這種可能會用在一些同時啟動的線程中，按照優先級保證重要線程的執行，也可以是其他一些特殊的業務場景（例如這個線程內容很耗時，又不那么重要，可以放在后面）。
為了驗證這個方法，我們做一個例子：啟動50個線程進行，每個線程都進行1000次的加和計算。其中10個線程會執行讓出CPU操作。「那么」，如果讓出CPU那10個線程的計算加和時間都比較長，說明確實在進行讓出操作。
「案例代碼」
private static volatile Map<String, AtomicInteger> count = new ConcurrentHashMap<>();
static class Y implements Runnable {
private String name;
private boolean isYield;
public Y(String name, boolean isYield) {
this.name = name;
this.isYield = isYield;
}
@Override
public void run() {
long l = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
if (isYield) Thread.yield();
AtomicInteger atomicInteger = count.get(name);
if (null == atomicInteger) {
count.put(name, new AtomicInteger(1));
continue;
}
atomicInteger.addAndGet(1);
count.put(name, atomicInteger);
}
System.out.println("線程編號：" + name + " 執行完成耗時：" + (System.currentTimeMillis() - l) + " (毫秒)" + (isYield ? "讓出CPU----------------------" : "不讓CPU"));
}
}
public static void main(String[] args) {
for (int i = 0; i < 50; i++) {
if (i < 10) {
new Thread(new Y(String.valueOf(i), true)).start();
continue;
}
new Thread(new Y(String.valueOf(i), false)).start();
}
} 「測試結果」
線程編號：10 執行完成耗時：2 (毫秒)不讓CPU
線程編號：11 執行完成耗時：2 (毫秒)不讓CPU
線程編號：15 執行完成耗時：1 (毫秒)不讓CPU
線程編號：14 執行完成耗時：1 (毫秒)不讓CPU
線程編號：19 執行完成耗時：1 (毫秒)不讓CPU
線程編號：18 執行完成耗時：1 (毫秒)不讓CPU
線程編號：22 執行完成耗時：0 (毫秒)不讓CPU
線程編號：26 執行完成耗時：0 (毫秒)不讓CPU
線程編號：27 執行完成耗時：1 (毫秒)不讓CPU
線程編號：30 執行完成耗時：0 (毫秒)不讓CPU
線程編號：31 執行完成耗時：0 (毫秒)不讓CPU
線程編號：34 執行完成耗時：1 (毫秒)不讓CPU
線程編號：12 執行完成耗時：1 (毫秒)不讓CPU
線程編號：16 執行完成耗時：1 (毫秒)不讓CPU
線程編號：13 執行完成耗時：1 (毫秒)不讓CPU
線程編號：17 執行完成耗時：1 (毫秒)不讓CPU
線程編號：20 執行完成耗時：0 (毫秒)不讓CPU
線程編號：23 執行完成耗時：0 (毫秒)不讓CPU
線程編號：21 執行完成耗時：0 (毫秒)不讓CPU
線程編號：25 執行完成耗時：1 (毫秒)不讓CPU
線程編號：24 執行完成耗時：1 (毫秒)不讓CPU
線程編號：28 執行完成耗時：0 (毫秒)不讓CPU
線程編號：38 執行完成耗時：0 (毫秒)不讓CPU
線程編號：39 執行完成耗時：0 (毫秒)不讓CPU
線程編號：37 執行完成耗時：1 (毫秒)不讓CPU
線程編號：40 執行完成耗時：0 (毫秒)不讓CPU
線程編號：44 執行完成耗時：0 (毫秒)不讓CPU
線程編號：36 執行完成耗時：1 (毫秒)不讓CPU
線程編號：42 執行完成耗時：1 (毫秒)不讓CPU
線程編號：45 執行完成耗時：1 (毫秒)不讓CPU
線程編號：43 執行完成耗時：1 (毫秒)不讓CPU
線程編號：46 執行完成耗時：0 (毫秒)不讓CPU
線程編號：47 執行完成耗時：0 (毫秒)不讓CPU
線程編號：35 執行完成耗時：0 (毫秒)不讓CPU
線程編號：33 執行完成耗時：0 (毫秒)不讓CPU
線程編號：32 執行完成耗時：0 (毫秒)不讓CPU
線程編號：41 執行完成耗時：0 (毫秒)不讓CPU
線程編號：48 執行完成耗時：1 (毫秒)不讓CPU
線程編號：6 執行完成耗時：15 (毫秒)讓出CPU----------------------
線程編號：7 執行完成耗時：15 (毫秒)讓出CPU----------------------
線程編號：49 執行完成耗時：2 (毫秒)不讓CPU
線程編號：29 執行完成耗時：1 (毫秒)不讓CPU
線程編號：2 執行完成耗時：17 (毫秒)讓出CPU----------------------
線程編號：1 執行完成耗時：11 (毫秒)讓出CPU----------------------
線程編號：4 執行完成耗時：15 (毫秒)讓出CPU----------------------
線程編號：8 執行完成耗時：12 (毫秒)讓出CPU----------------------
線程編號：5 執行完成耗時：12 (毫秒)讓出CPU----------------------
線程編號：9 執行完成耗時：12 (毫秒)讓出CPU----------------------
線程編號：0 執行完成耗時：21 (毫秒)讓出CPU----------------------
線程編號：3 執行完成耗時：21 (毫秒)讓出CPU----------------------
wait 和 notify/nofityall，是一對方法，有一個等待，就會有一個叫醒，否則程序就夯在那不動了。關于這部分會使用到的 synchronized 在之前小傅哥有深入的源碼分析，講到它是怎么加鎖在對象頭的，如果你忘記了可以翻翻看 《synchronized 解毒，剖析源碼深度分析！》
接下來我們模擬鹿鼎記·麗春院，清倌喝茶吟詩聊風月日常。當有達官貴人來時，需要分配清倌給大老爺。中間會有一些等待、叫醒操作。只為讓你更好的記住這樣的案例，不要想歪嘍。清倌人即是只賣藝歡場人，喊麥的。
「案例代碼」
public class 麗春院 {
public static void main(String[] args) {
老鴇 鴇子 = new 老鴇();
清倌 miss = new 清倌(鴇子);
客官 guest = new 客官(鴇子);
Thread t_miss = new Thread(miss);
Thread t_guest = new Thread(guest);
t_miss.start();
t_guest.start();
}
}
class 清倌 implements Runnable {
老鴇 鴇子;
public 清倌(老鴇 鴇子) {
this.鴇子 = 鴇子;
}
@Override
public void run() {
int i = 1;
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
if (i == 1) {
try {
鴇子.在崗清倌("蒼田野子", "500 日元");
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
try {
鴇子.在崗清倌("花田崗子", "800 日元");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
i = (i + 1) % 2;
}
}
}
class 客官 implements Runnable {
老鴇 鴇子;
public 客官(老鴇 鴇子) {
this.鴇子 = 鴇子;
}
@Override
public void run() {
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
try {
鴇子.喝茶吟詩聊風月();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class 老鴇 {
private String 清倌 = null;
private String price = null;
private boolean 工作狀態 = true;
public synchronized void 在崗清倌(String 清倌, String price) throws InterruptedException {
if (!工作狀態)
wait();//等待
this.清倌 = 清倌;
this.price = price;
工作狀態 = false;
notify();//叫醒
}
public synchronized void 喝茶吟詩聊風月() throws InterruptedException {
if (工作狀態)
wait();//等待
System.out.println("聊風月：" + 清倌);
System.out.println("茶水費：" + price);
System.out.println(" " + " " + " " + " " + " " + " " + " " + " " + " " + " " + 清倌 + "完事" + "準備 ... ...");
System.out.println("****************************************");
工作狀態 = true;
notify();//叫醒
}
}「測試結果」
聊風月：蒼田野子
茶水費：500 日元
蒼田野子完事準備 ... ...
****************************************
聊風月：花田崗子
茶水費：800 日元
花田崗子完事準備 ... ...
****************************************
聊風月：蒼田野子
茶水費：500 日元
蒼田野子完事準備 ... ...
****************************************
...
join 是兩個線程的合并嗎？不是的！
join 是讓線程進入 wait ，當線程執行完畢后，會在JVM源碼中找到，它執行完畢后，其實執行notify，也就是 等待 和 叫醒 操作。
「源碼」：jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp
void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
// Notify waiters on thread object. This has to be done after exit() is called
// on the thread (if the thread is the last thread in a daemon ThreadGroup the
// group should have the destroyed bit set before waiters are notified).
ensure_join(this);
}
static void ensure_join(JavaThread* thread) {
// 叫醒
java_lang_Thread::set_thread(threadObj(), NULL);
lock.notify_all(thread);
}
好的，就是這里！lock.notify_all(thread)，執行到這，就對上了。
「案例代碼」
Thread thread = new Thread(() -> {
System.out.println("thread before");
try {
Thread.sleep(3000);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("thread after");
});
thread.start();
System.out.println("main begin！");
thread.join();
System.out.println("main end！"); 「測試結果」
main begin！
thread before
thread after
main end！
Process finished with exit code 0
首先join() 是一個synchronized方法， 里面調用了wait()，這個過程的目的是讓持有這個同步鎖的線程進入等待，那么誰持有了這個同步鎖呢？答案是主線程，因為主線程調用了threadA.join()方法，相當于在threadA.join()代碼這塊寫了一個同步代碼塊，誰去執行了這段代碼呢，是主線程，所以主線程被wait()了。然后在子線程threadA執行完畢之后，JVM會調用lock.notify_all(thread);喚醒持有threadA這個對象鎖的線程，也就是主線程，會繼續執行。
thread.join() 后，會影響到輸出結果。如果不加，
main end！ 會優先
thread after 提前打印出來。到此，相信大家對“總結Thread線程，狀態轉換、方法使用、原理分析”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
