面經手冊 · 第20篇《Thread 執行緒,狀態轉換、方法使用、原理分析》

小傅哥發表於2020-12-03


作者:小傅哥
部落格:https://bugstack.cn
Github:https://github.com/fuzhengwei/CodeGuide/wiki

沉澱、分享、成長,讓自己和他人都能有所收穫!?

一、前言

考不常用的、考你不會的、考你忽略的,才是考試!

大部分考試考的,基本都是不怎麼用的。例外的我們們不說? 就像你做程式開發,尤其在RPC+MQ+分庫分表,其實很難出現讓你用一個機器例項編寫多執行緒壓榨CPU效能。很多時候是扔出一個MQ,非同步消費了。如果沒有資源競爭,例如庫表秒殺,那麼其實你確實很難接觸多併發程式設計以及鎖的使用。

但!凡有例外,比如你需要開發一個資料庫路由中介軟體,那麼就肯定會出現在一臺應用例項上分配資料庫資源池的情況,如果出現競爭就要合理分配資源。如此,類似這樣的中介軟體開發,就會涉及到一些更核心底層的技術的應用。

所以,有時候不是沒用,而是你沒有

二、面試題

謝飛機,小記! 執行緒我玩定了,面試也攔不住我,我說的!

謝飛機:嘿,你好哇,我是謝飛機!

面試官:好,今天電話面試,你準備好了?

謝飛機:準備好了,嘿嘿!

面試官:嗯,我看你簡歷裡寫了不少執行緒的東西,看來了解的不錯。問你一個執行緒吧那就,執行緒之間狀態是怎麼轉換的?

謝飛機:扒拉扒拉,扒拉扒拉!

面試官:嗯,還不錯。那 yield 方法是怎麼使用的。

謝飛機:嗯!好像是讓出CPU。具體的沒怎麼用過!

面試官:做做測試,驗證下,下次問你。

三、Thread 狀態關係

Java 的執行緒狀態描述在列舉類 java.lang.Thread.State 中,共包括如下五種狀態:

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

這五種狀態描述了一個執行緒的生命週期,其實這種狀態碼的定義在我們日常的業務開發中,也經常出現。比如:一個活動的提交、稽核、拒絕、修改、通過、執行、關閉等,是類似的。那麼執行緒的狀態是通過下圖的方式進行流轉的,如圖 20-1

圖 20-1 執行緒狀態流轉

  • New:新建立的一個執行緒,處於等待狀態。
  • Runnable:可執行狀態,並不是已經執行,具體的執行緒排程各作業系統決定。在 Runnable 中包含了 ReadyRunning 兩個狀態,當執行緒呼叫了 start() 方法後,執行緒則處於就緒 Ready 狀態,等待作業系統分配 CPU 時間片,分配後則進入 Running 執行狀態。此外當呼叫 yield() 方法後,只是謙讓的允許當前執行緒讓出CPU,但具體讓不讓不一定,由作業系統決定。如果讓了,那麼當前執行緒則會處於 Ready 狀態繼續競爭CPU,直至執行。
  • Timed_waiting:指定時間內讓出CPU資源,此時執行緒不會被執行,也不會被系統排程,直到等待時間到期後才會被執行。下列方法都可以觸發:Thread.sleepObject.waitThread.joinLockSupport.parkNanosLockSupport.parkUntil
  • Wating:可被喚醒的等待狀態,此時執行緒不會被執行也不會被系統排程。此狀態可以通過 synchronized 獲得鎖,呼叫 wait 方法進入等待狀態。最後通過 notify、notifyall 喚醒。下列方法都可以觸發:Object.waitThread.joinLockSupport.park
  • Blocked:當發生鎖競爭狀態下,沒有獲得鎖的執行緒會處於掛起狀態。例如 synchronized 鎖,先獲得的先執行,沒有獲得的進入阻塞狀態。
  • Terminated:這個是終止狀態,從 New 到 Terminated 是不可逆的。一般是程式流程正常結束或者發生了異常。

這裡參考列舉State 類的英文註釋瞭解了每一個狀態碼的含義,接下來我們去嘗試操作執行緒方法,把這些狀態體現出來。

四、Thread 狀態測試

1. NEW

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

// NEW
  • 這個狀態很簡單,就是執行緒建立還沒有啟動時就是這個狀態。

2. RUNNABLE

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

// RUNNABLE
  • 建立的執行緒啟動後 start(),就會進入 RUNNABLE 狀態。但此時並不一定在執行,而是說這個執行緒已經就緒,可以競爭 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
  • 這段程式碼稍微有點長,主要是為了讓兩個執行緒發生鎖競爭。
  • 第一個執行緒,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 狀態。
  • 另外 Thread.join 原始碼中也是呼叫的 wait 方法,所以也會讓執行緒進入等待狀態。

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
  • 有了上面狀態獲取的對比,這個狀態的獲取就沒什麼難度了。只要改成 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 狀態。

五、Thread 方法使用

一般情況下 Thread 中最常用的方法就是 start 啟動,除此之外一些其他方法可能在平常的開發中用的不多,但這些方法在一些框架中卻經常出現。因此只瞭解它們的概念,但是卻缺少一些例項來參考! 接下來我們就來做一些案例來驗證這些方法,包括:yield、wait、notify、join。

1. yield

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----------------------
  • 從測試結果可以看到,那些讓出 CPU 的,執行完計算已經在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 工作狀態 = 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 日元
                    蒼田野子完事準備 ... ...
****************************************

...
  • 效果效果主要體現 wait、notify,這兩個方法的使用。我相信你一定能記住這個例子!

3. join

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 提前列印出來。
  • join() 是一個 synchronized 方法,裡面呼叫了 wait() 方法,讓持有當前同步鎖的執行緒進入等待狀態,也就是主執行緒。當子執行緒執行完畢後,我們從原始碼中可以看到 JVM 呼叫了 lock.notify_all(thread) 所以喚醒了主執行緒繼續執行。

六、總結

  • 執行緒狀態和狀態的轉換也是面試中必問的問題,但除了面試是我們自己在開發中,如果真的使用執行緒,是非常有必要了解執行緒狀態是如何轉換的。模模糊糊的使用,總會覺得擔心,那麼你是個好程式設計師!
  • 執行緒的一些深入學習都是在呼叫本地方法,也就是需要了解到JVM層面,才能更加深刻的見到c++程式碼是如何實現這部分邏輯的。
  • 在使用執行緒的時候一定要讓自己有一個類似多核的腦子,執行緒一起、生死由你!本章節就扯到這了,很多的知識都是為了整套內容體系的全面,為後續介紹其他知識打下根基。感謝!

七、系列推薦

相關文章