面試題精選:兩個執行緒按順序交替輸出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++和輸出，當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的底層實作

決議：這個可以參考下網上其他博客，這里不再詳細展開

歡迎關注我的專欄《面試題精選》，長期更新、永久免費，希望能幫到大家，

本文來自https://blog.csdn.net/xindoo

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/1922.html

標籤：Java

上一篇：JAVA 執行緒

下一篇：JAVA 執行緒同步