面試題精選:兩個執行緒按順序交替輸出1-100
陸陸續續，各個公司的校招季都開始了，我也成為了我司的校招面試官，最近也面了不少同學了，面試過程中也發現了很多問題，即有面試者的、也有面試官的、更有自己的問題，這裡先挖個坑，後續寫個部落格詳細聊聊，感興趣的同學可以關注下。另外，我也有個專欄《面試題精選》，裡面收錄我之前寫的一些面試題部落格，長期更新、永久免費，近期我會多寫一些面試題相關的部落格，希望能幫助到在找工作的各位。
今天分享一道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++
- 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的底層實現
解析：這個可以參考下網上其他部落格，這裡不再詳細展開
歡迎關注我的專欄《面試題精選》，長期更新、永久免費，希望能幫到大家。