總結Thread線程，狀態(tài)轉換、方法使用、原理分析

一、前言

考不常用的、考你不會的、考你忽略的，才是考試！

大部分考試考的，基本都是不怎么用的。例外的咱們不說???? 就像你做程序開發(fā)，尤其在RPC+MQ+分庫分表，其實很難出現(xiàn)讓你用一個機器實例編寫多線程壓榨CPU性能。很多時候是扔出一個MQ，異步消費了。如果沒有資源競爭，例如庫表秒殺，那么其實你確實很難接觸多并發(fā)編程以及鎖的使用。

但！凡有例外，比如你需要開發(fā)一個數(shù)據(jù)庫路由中間件，那么就肯定會出現(xiàn)在一臺應用實例上分配數(shù)據(jù)庫資源池的情況，如果出現(xiàn)競爭就要合理分配資源。如此，類似這樣的中間件開發(fā)，就會涉及到一些更核心底層的技術的應用。

所以，有時候不是沒用，而是你沒有用。

二、面試題

謝飛機，小記！ 線程我玩定了，面試也攔不住我，我說的！

「謝飛機」：嘿，你好哇，我是謝飛機！

「面試官」：好，今天電話面試，你準備好了？

「謝飛機」：準備好了，嘿嘿！

「面試官」：嗯，我看你簡歷里寫了不少線程的東西，看來了解的不錯。問你一個線程吧那就，線程之間狀態(tài)是怎么轉換的？

「謝飛機」：扒拉扒拉，扒拉扒拉！

「面試官」：嗯，還不錯。那 yield 方法是怎么使用的。

「謝飛機」：嗯！好像是讓出CPU。具體的沒怎么用過！

「面試官」：做做測試，驗證下，下次問你。

三、Thread 狀態(tài)關系

Java 的線程狀態(tài)描述在枚舉類 java.lang.Thread.State 中，共包括如下五種狀態(tài)：

public enum State {
    NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED;
}

這五種狀態(tài)描述了一個線程的生命周期，其實這種狀態(tài)碼的定義在我們日常的業(yè)務開發(fā)中，也經(jīng)常出現(xiàn)。比如：一個活動的提交、審核、拒絕、修改、通過、運行、關閉等，是類似的。那么線程的狀態(tài)是通過下圖的方式進行流轉的，如圖 20-1

 

• New：新創(chuàng)建的一個線程，處于等待狀態(tài)。
• Runnable：可運行狀態(tài)，并不是已經(jīng)運行，具體的線程調度各操作系統(tǒng)決定。在 Runnable 中包含了     Ready、     Running 兩個狀態(tài)，當線程調用了 start() 方法后，線程則處于就緒 Ready 狀態(tài)，等待操作系統(tǒng)分配 CPU 時間片，分配后則進入 Running 運行狀態(tài)。此外當調用 yield() 方法后，只是     謙讓的允許當前線程讓出CPU，但具體讓不讓不一定，由操作系統(tǒng)決定。如果讓了，那么當前線程則會處于 Ready 狀態(tài)繼續(xù)競爭CPU，直至執(zhí)行。
• Timed_waiting：指定時間內讓出CPU資源，此時線程不會被執(zhí)行，也不會被系統(tǒng)調度，直到等待時間到期后才會被執(zhí)行。下列方法都可以觸發(fā)：     Thread.sleep、     Object.wait、     Thread.join、     LockSupport.parkNanos、     LockSupport.parkUntil。
• Wating：可被喚醒的等待狀態(tài)，此時線程不會被執(zhí)行也不會被系統(tǒng)調度。此狀態(tài)可以通過 synchronized 獲得鎖，調用 wait 方法進入等待狀態(tài)。最后通過 notify、notifyall 喚醒。下列方法都可以觸發(fā)：     Object.wait、     Thread.join、     LockSupport.park。
• Blocked：當發(fā)生鎖競爭狀態(tài)下，沒有獲得鎖的線程會處于掛起狀態(tài)。例如 synchronized 鎖，先獲得的先執(zhí)行，沒有獲得的進入阻塞狀態(tài)。
• Terminated：這個是終止狀態(tài)，從 New 到 Terminated 是不可逆的。一般是程序流程正常結束或者發(fā)生了異常。

這里參考枚舉State 類的英文注釋了解了每一個狀態(tài)碼的含義，接下來我們去嘗試操作線程方法，把這些狀態(tài)體現(xiàn)出來。 

四、Thread 狀態(tài)測試 

1. NEW

Thread thread = new Thread(() -> {
});
System.out.println(thread.getState());

// NEW

• 這個狀態(tài)很簡單，就是線程創(chuàng)建還沒有啟動時就是這個狀態(tài)。 

2. RUNNABLE

Thread thread = new Thread(() -> {
});
// 啟動
thread.start();
System.out.println(thread.getState());

// RUNNABLE

• 創(chuàng)建的線程啟動后     start()，就會進入 RUNNABLE 狀態(tài)。但此時并不一定在執(zhí)行，而是說這個線程已經(jīng)就緒，可以競爭 CPU 資源。 

3. BLOCKED

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

• 這段代碼稍微有點長，主要是為了讓兩個線程發(fā)生鎖競爭。
• 第一個線程，synchronized 獲取鎖后休眠，不釋放鎖。
• 第二個線程，synchronized 獲取不到鎖，會被掛起。
• 那么最后的輸出結果就會是，     BLOCKED 

4. WAITING

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

• 只要在 synchronized 代碼塊或者修飾的方法中，調用     wait 方法，又沒有被 notify 就會進入     WAITING 狀態(tài)。
• 另外     Thread.join 源碼中也是調用的 wait 方法，所以也會讓線程進入等待狀態(tài)。 

5. TIMED_WAITING

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

• 有了上面狀態(tài)獲取的對比，這個狀態(tài)的獲取就沒什么難度了。只要改成     Thread.sleep(100000); 就可以了。

6. TERMINATED

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 狀態(tài)。

五、Thread 方法使用

一般情況下 Thread 中最常用的方法就是 start 啟動，除此之外一些其他方法可能在平常的開發(fā)中用的不多，但這些方法在一些框架中卻經(jīng)常出現(xiàn)。因此只了解它們的概念，但是卻缺少一些實例來參考！ 接下來我們就來做一些案例來驗證這些方法，包括：yield、wait、notify、join。

1. yield

yield 方法讓出CPU，但不一定，一定讓出！。這種可能會用在一些同時啟動的線程中，按照優(yōu)先級保證重要線程的執(zhí)行，也可以是其他一些特殊的業(yè)務場景（例如這個線程內容很耗時，又不那么重要，可以放在后面）。

為了驗證這個方法，我們做一個例子：啟動50個線程進行，每個線程都進行1000次的加和計算。其中10個線程會執(zhí)行讓出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 + " 執(zhí)行完成耗時：" + (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 執(zhí)行完成耗時：2 (毫秒)不讓CPU
線程編號：11 執(zhí)行完成耗時：2 (毫秒)不讓CPU
線程編號：15 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：14 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：19 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：18 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：22 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：26 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：27 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：30 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：31 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：34 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：12 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：16 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：13 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：17 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：20 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：23 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：21 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：25 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：24 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：28 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：38 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：39 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：37 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：40 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：44 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：36 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：42 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：45 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：43 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：46 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：47 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：35 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：33 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：32 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：41 執(zhí)行完成耗時：0 (毫秒)不讓CPU
線程編號：48 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：6 執(zhí)行完成耗時：15 (毫秒)讓出CPU----------------------
線程編號：7 執(zhí)行完成耗時：15 (毫秒)讓出CPU----------------------
線程編號：49 執(zhí)行完成耗時：2 (毫秒)不讓CPU
線程編號：29 執(zhí)行完成耗時：1 (毫秒)不讓CPU
線程編號：2 執(zhí)行完成耗時：17 (毫秒)讓出CPU----------------------
線程編號：1 執(zhí)行完成耗時：11 (毫秒)讓出CPU----------------------
線程編號：4 執(zhí)行完成耗時：15 (毫秒)讓出CPU----------------------
線程編號：8 執(zhí)行完成耗時：12 (毫秒)讓出CPU----------------------
線程編號：5 執(zhí)行完成耗時：12 (毫秒)讓出CPU----------------------
線程編號：9 執(zhí)行完成耗時：12 (毫秒)讓出CPU----------------------
線程編號：0 執(zhí)行完成耗時：21 (毫秒)讓出CPU----------------------
線程編號：3 執(zhí)行完成耗時：21 (毫秒)讓出CPU----------------------

• 從測試結果可以看到，那些讓出 CPU 的，執(zhí)行完計算已經(jīng)在10毫秒以上，說明我們的測試是效果的。 

2. wait & notify

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 工作狀態(tài) = true;

    public synchronized void 在崗清倌(String 清倌, String price) throws InterruptedException {
        if (!工作狀態(tài))
            wait();//等待
        this.清倌 = 清倌;
        this.price = price;
        工作狀態(tài) = false;
        notify();//叫醒
    }

    public synchronized void 喝茶吟詩聊風月() throws InterruptedException {
        if (工作狀態(tài))
            wait();//等待
        System.out.println("聊風月：" + 清倌);
        System.out.println("茶水費：" + price);
        System.out.println("  " + "  " + "  " + "  " + "  " + "  " + "  " + "  " + "  " + "  " + 清倌 + "完事" + "準備 ... ...");
        System.out.println("****************************************");
        工作狀態(tài) = true;
        notify();//叫醒
    }

}

「測試結果」

聊風月：蒼田野子
茶水費：500 日元
                    蒼田野子完事準備 ... ...
****************************************
聊風月：花田崗子
茶水費：800 日元
                    花田崗子完事準備 ... ...
****************************************
聊風月：蒼田野子
茶水費：500 日元
                    蒼田野子完事準備 ... ...
****************************************

...

• 效果效果主要體現(xiàn) wait、notify，這兩個方法的使用。     我相信你一定能記住這個例子！

3. join

join 是兩個線程的合并嗎？不是的！

join 是讓線程進入 wait ，當線程執(zhí)行完畢后，會在JVM源碼中找到，它執(zhí)行完畢后，其實執(zhí)行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)，執(zhí)行到這，就對上了。

「案例代碼」

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()代碼這塊寫了一個同步代碼塊，誰去執(zhí)行了這段代碼呢，是主線程，所以主線程被wait()了。然后在子線程threadA執(zhí)行完畢之后，JVM會調用lock.notify_all(thread);喚醒持有threadA這個對象鎖的線程，也就是主線程，會繼續(xù)執(zhí)行。

• 這部分驗證的主要體現(xiàn)就是加了     thread.join() 后，會影響到輸出結果。如果不加，     main end！ 會優(yōu)先     thread after 提前打印出來。
• 「join() 是一個 synchronized 方法」，里面調用了 wait() 方法，讓持有當前同步鎖的線程進入等待狀態(tài)，也就是主線程。當子線程執(zhí)行完畢后，我們從源碼中可以看到 JVM 調用了 lock.notify_all(thread) 所以喚醒了主線程繼續(xù)執(zhí)行。