一、前言

考不常用的、考你不會(huì)的、考你忽略的，才是考試！

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

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

所以，有時(shí)候不是沒(méi)用，而是你沒(méi)有用。 

二、面試題

謝飛機(jī)，小記！ 線(xiàn)程我玩定了，面試也攔不住我，我說(shuō)的！

「謝飛機(jī)」：嘿，你好哇，我是謝飛機(jī)！

「面試官」：好，今天電話(huà)面試，你準(zhǔn)備好了？

「謝飛機(jī)」：準(zhǔn)備好了，嘿嘿！

「面試官」：嗯，我看你簡(jiǎn)歷里寫(xiě)了不少線(xiàn)程的東西，看來(lái)了解的不錯(cuò)。問(wèn)你一個(gè)線(xiàn)程吧那就，線(xiàn)程之間狀態(tài)是怎么轉(zhuǎn)換的？

「謝飛機(jī)」：扒拉扒拉，扒拉扒拉！

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

「謝飛機(jī)」：嗯！好像是讓出CPU。具體的沒(méi)怎么用過(guò)！

「面試官」：做做測(cè)試，驗(yàn)證下，下次問(wèn)你。

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

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

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

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

 

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

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

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

1. NEW

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

// NEW

• 這個(gè)狀態(tài)很簡(jiǎn)單，就是線(xiàn)程創(chuàng)建還沒(méi)有啟動(dòng)時(shí)就是這個(gè)狀態(tài)。 

2. RUNNABLE

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

// RUNNABLE

• 創(chuàng)建的線(xiàn)程啟動(dòng)后     start()，就會(huì)進(jìn)入 RUNNABLE 狀態(tài)。但此時(shí)并不一定在執(zhí)行，而是說(shuō)這個(gè)線(xiàn)程已經(jīng)就緒，可以競(jìng)爭(zhē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

• 這段代碼稍微有點(diǎn)長(zhǎng)，主要是為了讓兩個(gè)線(xiàn)程發(fā)生鎖競(jìng)爭(zhēng)。
• 第一個(gè)線(xiàn)程，synchronized 獲取鎖后休眠，不釋放鎖。
• 第二個(gè)線(xiàn)程，synchronized 獲取不到鎖，會(huì)被掛起。
• 那么最后的輸出結(jié)果就會(huì)是，     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 代碼塊或者修飾的方法中，調(diào)用     wait 方法，又沒(méi)有被 notify 就會(huì)進(jìn)入     WAITING 狀態(tài)。
• 另外     Thread.join 源碼中也是調(diào)用的 wait 方法，所以也會(huì)讓線(xiàn)程進(jìn)入等待狀態(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)獲取的對(duì)比，這個(gè)狀態(tài)的獲取就沒(mé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

• 這個(gè)就比較簡(jiǎn)單了，只要一個(gè)線(xiàn)程運(yùn)行完，它的生命周期結(jié)束了，就進(jìn)入了     TERMINATED 狀態(tài)。

五、Thread 方法使用

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

1. yield

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

為了驗(yàn)證這個(gè)方法，我們做一個(gè)例子：?jiǎn)?dòng)50個(gè)線(xiàn)程進(jìn)行，每個(gè)線(xiàn)程都進(jìn)行1000次的加和計(jì)算。其中10個(gè)線(xiàn)程會(huì)執(zhí)行讓出CPU操作。「那么」，如果讓出CPU那10個(gè)線(xiàn)程的計(jì)算加和時(shí)間都比較長(zhǎng)，說(shuō)明確實(shí)在進(jìn)行讓出操作。

「案例代碼」

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("線(xiàn)程編號(hào)：" + name + " 執(zhí)行完成耗時(shí)：" + (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();
    }
} 

「測(cè)試結(jié)果」

線(xiàn)程編號(hào)：10 執(zhí)行完成耗時(shí)：2 (毫秒)不讓CPU
線(xiàn)程編號(hào)：11 執(zhí)行完成耗時(shí)：2 (毫秒)不讓CPU
線(xiàn)程編號(hào)：15 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：14 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：19 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：18 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：22 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：26 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：27 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：30 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：31 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：34 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：12 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：16 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：13 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：17 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：20 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：23 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：21 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：25 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：24 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：28 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：38 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：39 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：37 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：40 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：44 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：36 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：42 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：45 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：43 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：46 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：47 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：35 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：33 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：32 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：41 執(zhí)行完成耗時(shí)：0 (毫秒)不讓CPU
線(xiàn)程編號(hào)：48 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：6 執(zhí)行完成耗時(shí)：15 (毫秒)讓出CPU----------------------
線(xiàn)程編號(hào)：7 執(zhí)行完成耗時(shí)：15 (毫秒)讓出CPU----------------------
線(xiàn)程編號(hào)：49 執(zhí)行完成耗時(shí)：2 (毫秒)不讓CPU
線(xiàn)程編號(hào)：29 執(zhí)行完成耗時(shí)：1 (毫秒)不讓CPU
線(xiàn)程編號(hào)：2 執(zhí)行完成耗時(shí)：17 (毫秒)讓出CPU----------------------
線(xiàn)程編號(hào)：1 執(zhí)行完成耗時(shí)：11 (毫秒)讓出CPU----------------------
線(xiàn)程編號(hào)：4 執(zhí)行完成耗時(shí)：15 (毫秒)讓出CPU----------------------
線(xiàn)程編號(hào)：8 執(zhí)行完成耗時(shí)：12 (毫秒)讓出CPU----------------------
線(xiàn)程編號(hào)：5 執(zhí)行完成耗時(shí)：12 (毫秒)讓出CPU----------------------
線(xiàn)程編號(hào)：9 執(zhí)行完成耗時(shí)：12 (毫秒)讓出CPU----------------------
線(xiàn)程編號(hào)：0 執(zhí)行完成耗時(shí)：21 (毫秒)讓出CPU----------------------
線(xiàn)程編號(hào)：3 執(zhí)行完成耗時(shí)：21 (毫秒)讓出CPU----------------------

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

2. wait & notify

wait 和 notify/nofityall，是一對(duì)方法，有一個(gè)等待，就會(huì)有一個(gè)叫醒，否則程序就夯在那不動(dòng)了。關(guān)于這部分會(huì)使用到的 synchronized 在之前小傅哥有深入的源碼分析，講到它是怎么加鎖在對(duì)象頭的，如果你忘記了可以翻翻看 《synchronized 解毒，剖析源碼深度分析！》

接下來(lái)我們模擬鹿鼎記·麗春院，清倌喝茶吟詩(shī)聊風(fēng)月日常。當(dāng)有達(dá)官貴人來(lái)時(shí)，需要分配清倌給大老爺。中間會(huì)有一些等待、叫醒操作。只為讓你更好的記住這樣的案例，不要想歪嘍。清倌人即是只賣(mài)藝歡場(chǎng)人，喊麥的。

「案例代碼」

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 {
                鴇子.喝茶吟詩(shī)聊風(fēng)月();
            } 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 喝茶吟詩(shī)聊風(fēng)月() throws InterruptedException {
        if (工作狀態(tài))
            wait();//等待
        System.out.println("聊風(fēng)月：" + 清倌);
        System.out.println("茶水費(fèi)：" + price);
        System.out.println("  " + "  " + "  " + "  " + "  " + "  " + "  " + "  " + "  " + "  " + 清倌 + "完事" + "準(zhǔn)備 ... ...");
        System.out.println("****************************************");
        工作狀態(tài) = true;
        notify();//叫醒
    }

}

「測(cè)試結(jié)果」

聊風(fēng)月：蒼田野子
茶水費(fèi)：500 日元
                    蒼田野子完事準(zhǔn)備 ... ...
****************************************
聊風(fēng)月：花田崗子
茶水費(fèi)：800 日元
                    花田崗子完事準(zhǔn)備 ... ...
****************************************
聊風(fēng)月：蒼田野子
茶水費(fèi)：500 日元
                    蒼田野子完事準(zhǔn)備 ... ...
****************************************

...

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

3. join

join 是兩個(gè)線(xiàn)程的合并嗎？不是的！

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

「案例代碼」

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！"); 

「測(cè)試結(jié)果」

main begin！
thread before
thread after
main end！

Process finished with exit code 0

首先join() 是一個(gè)synchronized方法， 里面調(diào)用了wait()，這個(gè)過(guò)程的目的是讓持有這個(gè)同步鎖的線(xiàn)程進(jìn)入等待，那么誰(shuí)持有了這個(gè)同步鎖呢？答案是主線(xiàn)程，因?yàn)橹骶€(xiàn)程調(diào)用了threadA.join()方法，相當(dāng)于在threadA.join()代碼這塊寫(xiě)了一個(gè)同步代碼塊，誰(shuí)去執(zhí)行了這段代碼呢，是主線(xiàn)程，所以主線(xiàn)程被wait()了。然后在子線(xiàn)程threadA執(zhí)行完畢之后，JVM會(huì)調(diào)用lock.notify_all(thread);喚醒持有threadA這個(gè)對(duì)象鎖的線(xiàn)程，也就是主線(xiàn)程，會(huì)繼續(xù)執(zhí)行。

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