陸陸續續，各個公司的校招季都開始了，我也成為了我司的校招面試官，最近也面了不少同學了，面試過程中也發現了很多問題，即有面試者的、也有面試官的、更有自己的問題，這里先挖個坑，后續寫個博客詳細聊聊，感興趣的同學可以關注下。另外，我也有個專欄《面試題精選》，里面收錄我之前寫的一些面試題博客，長期更新、永久免費，近期我會多寫一些面試題相關的博客，希望能幫助到在找工作的各位。
今天分享一道Java多線程的面試題，更多面試，我在幾年前面試的時候被問到過，當時我完全不知道怎么寫，畢竟那個時候我還是運維。現在我面試別人的時候偶爾也會問這個題目。具體題目是這樣的，兩個線程交替按順序輸出1-100，第一個線程只能輸出偶數，第二線程輸出奇數，想象下兩個小孩輪流喊數。
如果你沒有多線程編程的基礎，這道題你肯定不知道怎么做，但對於稍微學過點多線程編程的人來說似乎沒有那么難，所以我覺得這是道很好的卡是否有並發編程經驗的題。另外，從這道題可以擴展出很多知識點，所以它成為了中高級工程師面試的常見題。 這道題有很多的解法，接下來讓我們由簡入繁、逐步深入了解下，最后我也給出這道題的一些擴展題，希望你有所收獲。
兩個線程交替輸出，這就意味着它倆是需要協同的，協同意味着二者之間要有信息傳遞，如何相互傳遞信息？ 你可能直接想到，既然是0-100的數按順序交替輸出，那么每個進程只需要時不時看看計數器的值，然后看是否輪到自己輸出了就行。沒錯，這就是解法一的思路。
解法一
有了上面的思路，你肯定能快速寫出以下代碼：
public class PrintNumber extends Thread {
private static int cnt = 0;
private int id; // 線程編號
public PrintNumber(int id) {
this.id = id;
}
@Override
public void run() {
while (cnt < 100) {
while (cnt%2 == id) {
cnt++;
System.out.println("thread_" + id + " num:" + cnt);
}
}
}
public static void main(String[] args) {
Thread thread0 = new PrintNumber(0);
Thread thread1 = new PrintNumber(1);
thread0.start();
thread1.start();
}
}
但當你實際運行后會發現！！！
thread_0 num:1
thread_0 num:3
thread_1 num:3
thread_1 num:5
thread_1 num:6
thread_0 num:5
thread_0 num:8
thread_0 num:9
thread_1 num:8
thread_0 num:11
thread_1 num:11
.........
不僅順序不對，還有重復和丟失！問題在哪？回到代碼中cnt++; System.out.println("thread_" + id + " num:" + cnt); 這兩行，它主要包含兩個動作，cnt++和輸出，當cnt++執行完成后可能就已經觸發了另一個線程的輸出。簡化下執行流程，每個時刻JVM有4個動作要執行。
- thread_0 cnt++
- thread_0 print
- thread_1 cnt++
- thread_1 print
根據Java as-if-serial語義，jvm只保證單線程內的有序性，不保證多線程之間的有序性，所以上面4個步驟的執行次序可能是 1 2 3 4，也可能是1 3 2 4，更可能是1 3 4 2，對於上面的代碼而言就是最終次序可能會發生變化。另外，cnt++ 可以拆解為兩行底層指令，tmp = cnt + 1; cnt = tmp，當兩個線程同時執行上述指令時就會面臨和1 2 3 4步驟同樣的問題，…… 沒錯，多線程下的行為，和你女朋友的心思一樣難以琢磨。 如何解決這個問題？解決方案本質上都是保證代碼執行順和我們預期的一樣就行，正確的解法一和后面幾個解法本質上都是同樣的原理，只是實現方式不一樣。
解法一正確的代碼如下：
public class PrintNumber extends Thread {
private static AtomicInteger cnt = new AtomicInteger();
private int id;
public PrintNumber(int id) {
this.id = id;
}
@Override
public void run() {
while (cnt.get() <= 100) {
while (cnt.get()%2 == id) {
System.out.println("thread_" + id + " num:" + cnt.get());
cnt.incrementAndGet();
}
}
}
public static void main(String[] args) {
Thread thread0 = new PrintNumber(0);
Thread thread1 = new PrintNumber(1);
thread0.start();
thread1.start();
}
}
上面代碼通過AtomicInteger的incrementAndGet方法將cnt++的操作變成了一個原子操作，避免了多線程同時操作cnt導致的數據錯誤，另外，while (cnt.get()%2 == id也能保證只有單個線程才能進入while循環里執行，只有當前線程執行完inc后，下一個線程才能執行print，所以這個代碼是可以滿足我們交替輸出的需求的。 但是，這種方法很難駕馭，如果說我吧run函數寫成下面這樣：
@Override
public void run() {
while (cnt.get() <= 100) {
while (cnt.get()%2 == id) {
cnt.incrementAndGet();
System.out.println("thread_" + id + " num:" + cnt.get());
}
}
}
只需要把print和cnt.incrementAndGet()換個位置，結果就完全不一樣了，先inc可能導致在print執行前下一個線程就進入執行改變了cnt的值，導致結果錯誤。另外這種方法其實也不是嚴格正確的，如果不是print而是其他類似的場景，可能會出問題，所以這種寫法強烈不推薦。
解法二
事實上，我們只需要cnt++和print同時只有一個線程在執行就行了，所以我們可以簡單將方法一中錯誤的方案加上synchronized即可，代碼如下：
public class PrintNumber extends Thread {
private static int cnt = 0;
private int id; // 線程編號
public PrintNumber(int id) {
this.id = id;
}
@Override
public void run() {
while (cnt <= 100) {
while (cnt%2 == id) {
synchronized (PrintNumber.class) {
cnt++;
System.out.println("thread_" + id + " num:" + cnt);
}
}
}
}
public static void main(String[] args) {
Thread thread0 = new PrintNumber(0);
Thread thread1 = new PrintNumber(1);
thread0.start();
thread1.start();
}
}
這里我用了synchronized關鍵詞將cnt++和print包裝成了一個同步代碼塊，可以保證只有一個線程可以執行。這里不知道有沒有人會問，cnt需不需要聲明為volatile，我的回答是不需要，因為synchronized可以保證可見性。
大家有沒有發現，我上面代碼中一直都用了while (cnt.get()%2 == id)來判斷cnt是否是自己要輸出的數字，這就好比兩個小孩輪流報數，每個小孩都要耗費精力時不時看看是否到自己了，然后選擇是否報數，這樣顯然太低效了。能不能兩個小孩之間相互通知，一個小孩報完就通知下另一個小孩，然后自己休息，這樣明顯對雙方來說損耗的精力就少了很多。如果我們代碼能有類似的機制，這里就能損耗更少的無用功，提高性能。
這就得依賴於java的wait和notify機制，當一個線程執行完自己的工作，然后喚醒另一個線程，自己去休眠，這樣每個線程就不用忙等。代碼改造如下，這里我直接去掉了while (cnt.get()%2 == id)。
@Override
public void run() {
while (cnt <= 100) {
synchronized (PrintNumber.class) {
cnt++;
System.out.println("thread_" + id + " num:" + cnt);
PrintNumber.class.notify();
try {
PrintNumber.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
解法三
能用synchronized的地方就能用ReentrantLock，所以解法三和解法二本質上是一樣的，就是把synchronized換成了lock而已，然后把wait和notify換成Condition的signal和await，改造后的代碼如下：
public class PrintNumber extends Thread {
private static Lock lock = new ReentrantLock();
private static Condition condition = lock.newCondition();
private int id;
private static int cnt = 0;
public PrintNumber(int id) {
this.id = id;
}
private static void print(int id) {
}
@Override
public void run() {
while (cnt <= 100) {
lock.lock();
System.out.println("thread_" + id + " num:" + cnt);
cnt++;
condition.signal();
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.unlock();
}
}
public static void main(String[] args) {
Thread thread0 = new PrintNumber(0);
Thread thread1 = new PrintNumber(1);
thread0.start();
thread1.start();
}
}
到這里我所能想到的解法就這么多了，不知道你們還有沒有其他的解法，接下來我出幾道擴展問題，希望能幫你更深入理解這個題目涉及到的多線程的知識點。
擴展問題
1. 如果是三個線程交替輸出呢？
解析：三個線程的解法可以使用while (cnt%3 == id)的方式實現忙等，但簡單的喚醒+等待的方式必然不適用了， 沒有判斷的synchronized必然實現不了，java Object的notify和wait方法只能喚醒全部線程，然后另外兩個線程輸出前都需要額外判斷下是否輪到自己輸出了。這時候lock中condition的優勢就體現出來了，它可以通過設置不同的condition來實現不同線程的精確喚醒。
2. 生產者消費者
解析：兩個線程按順序交替輸出本質上就是多線程之間的相互協同，而這個領域另外一個非常有名且更常見的問題就是生產者消費者問題，兩個線程按順序交替輸出你可以認為是當生產者和單消費者的一種特殊情況，更多關於生產者消費者問題的實現可以參考我之前的博客https://blog.csdn.net/xindoo/article/details/80004003
3. synchronized和各種lock的底層實現
解析：這個可以參考下網上其他博客，這里不再詳細展開
歡迎關注我的專欄《面試題精選》，長期更新、永久免費，希望能幫到大家。