每日三道面試題，通往自由的道路8——多執行緒

太子爺哪吒發表於2021-06-29
面試題執行緒

茫茫人海千千萬萬，感謝這一秒你看到這裡。希望我的面試題系列能對你的有所幫助！共勉！

願你在未來的日子，保持熱愛，奔赴山海！

每日三道面試題，成就更好自我

今天我們繼續聊聊多執行緒的話題吧！

1. 昨天你講到建立執行緒後使用start方法去呼叫執行緒，為什麼run方法不行呢？有什麼區別？

這道題也是非常經典的一道題，雖然難度不大，但是突然忘了，也就答不上來了。

我們先來看看程式碼吧。

public class ThreadDemo {

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        MyThread myThead2 = new MyThread();
//        myThread.start();
//        myThead2.start();
        myThread.run();
        myThead2.run();
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 6; i++) {
            System.out.println(Thread.currentThread().getName() + " :" + i);
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

這裡我們建立了MyThread繼承了Thread類，這種方法是一種可以建立執行緒的方式。接著我們在main方法中建立了兩個執行緒，都呼叫了start方法和run方法。讓我們先看看結果吧！

// 註釋掉兩個run方法 開啟start方法得到的結果
Thread-0 :0
Thread-1 :0
Thread-1 :1
Thread-0 :1
Thread-1 :2
Thread-0 :2
Thread-1 :3
Thread-0 :3
Thread-1 :4
Thread-0 :4
Thread-1 :5
Thread-0 :5

// 註釋掉兩個start方法 開啟run方法得到的結果
main :0
main :1
main :2
main :3
main :4
main :5
main :0
main :1
main :2
main :3
main :4
main :5

接下來我們講一下：

  1. start方法的作用：

    啟動執行緒，相當於開啟一個執行緒呼叫我們重寫的run方法裡面的邏輯，此時相當於有兩個執行緒，一個main的主執行緒和開啟的子執行緒。可以看到我們的程式碼，相當於有三個執行緒，一個主執行緒、一個Thread-0執行緒和一個Thread-1執行緒。並且執行緒之間是沒有順序的，他們是搶佔cpu的資源來回切換的。

  2. run方法的作用：

    執行執行緒的執行時程式碼，相當於我們只是單純的呼叫一個普通方法。然後通過主執行緒的順序呼叫的方式，從myThread呼叫run方法結束後到myThread2去呼叫run方法結束，並且我們也可以看到我們控制檯中的執行緒名字就是main主執行緒。

  3. run方法我們可以重複呼叫，而start方法在一個執行緒中只能呼叫一次。即myThread這個例項物件只能呼叫一次start方法，如果再呼叫一次start方法的話，就會丟擲IllegalThreadStateException 的異常。

  4. 我們呼叫start方法算是真正意義上的多執行緒，因為它是額外開啟一個子執行緒去呼叫我們的run方法了。如果我們是呼叫run方法，就需要等待上一次的run方法執行完畢才能呼叫下一次。所以我們要呼叫start方法充分揮多核CPU的優勢，採用多執行緒的方式去同時完成幾件事情而不互相干擾。

妙啊，妙花種子妙妙秒啊！

2. 你知道你開啟一個執行緒後，它的狀態有那些嗎？

我們可以通過檢視Thread的原始碼中State列舉發現有6個狀態：

    public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

接下來我們具體來說說吧：

  • NEW(新建)

    執行緒剛被建立，還只是一個例項物件，並未呼叫start方法啟動。。MyThread myThread = new MyThread只有執行緒物件，沒有執行緒特徵。

  • Runnable(可執行)

    在建立物件物件完成後，呼叫了myThread.start()方法執行緒，可以在Java虛擬機器中執行的狀態，可能正在執行自己程式碼，也可能沒有，這取決於作業系統處理器。也可以叫做處於就緒狀態，需要等待被執行緒排程選中，獲取cpu資源的使用權。

  • Teminated(被終止)

    因為run方法正常退出而死亡，或者因為沒有捕獲的異常終止了run方法而死亡。代表著此執行緒的生命週期結束了。

處於執行狀態中的執行緒由於某種原因，暫時放棄對 CPU的使用權，停止執行，此時進入阻塞狀態，直到其進入到就緒狀態，才 有機會再次被 CPU 呼叫以進入到執行狀態。有以下三種相關阻塞狀態：

  • Blocked(鎖阻塞)

    當一個執行緒試圖獲取一個物件鎖如（Synchronzied或Lock），而該物件鎖被其他的執行緒持有，則該執行緒進入Blocked狀態；只有當該執行緒持有鎖時，該執行緒將變成Runnable狀態。

  • Waiting(無限等待)

    在呼叫了wait方法，JVM會把該執行緒放入等待佇列中，等待另一個執行緒執行一個（喚醒），該執行緒此時狀態表示進入Waiting狀態。進入這個狀態後是不能自動喚醒的，必須等待另一個執行緒呼叫notify或者notifyAll方法才能夠喚醒。

  • TimedWaiting(計時等待)

    同waiting狀態一樣，呼叫sleep方法或者其他超時方法時，他們將進入Timed Waiting狀態。不過這一狀態只需保持到超時期滿或者接收到喚醒通知。

可以，那問你最後一道：

3. 既然講到超時方法，那你講下sleep和wait的區別和他們需要怎樣喚醒

sleep和wait方法他們都是可以暫停當前執行緒的執行，進入一個阻塞狀態。

  • sleep：

    我們可以指定睡眠時間，即讓程式暫停指定時間執行，時間到了會繼續執行程式碼，如果時間未到我們想要換醒需要呼叫interrupt 方法來隨時喚醒即可。而呼叫interrupt 會使得sleep()方法丟擲InterruptedException 異常，當sleep()方法丟擲異常我們就中斷了sleep的方法，從而讓程式繼續執行下去。

  • wait：

    呼叫該方法，可以導致執行緒進入等待阻塞狀態，會一直等待直到它被其他執行緒通過notify或者notifyAll方法喚醒。或者也可以使用wait(long timeout)表示時間到了自動執行，類似於sleep(long millis)。

    notify()：該方法會隨機選擇一個在該物件上呼叫wait方法的執行緒，解除其阻塞狀態。

    notifyAll()：該方法會喚醒所有的wait物件。

兩者的區別：

  • 兩者所屬的類不同：sleep是 Thread執行緒類的靜態方法；而wait是 Object類的方法。

  • 兩者是否是否鎖呢：sleep不釋放鎖；wait釋放鎖。

  • 兩者所使用的場景：sleep可以在任何需要的場景下呼叫；而wait必須使用在同步程式碼塊或者同步方法中。

  • 兩者不同喚醒機制：sleep方法執行睡眠時間完成後，執行緒會自動甦醒；而wait方法被呼叫後，執行緒不會自動甦醒，需要別的執行緒呼叫同一個物件上的 notify或者 notifyAll方法，或者可以使用wait(long timeout)超時後執行緒會自動甦醒。

小夥子不錯嘛！今天就到這裡，期待你明天的到來，希望能讓我繼續保持驚喜！

注: 如果文章有任何錯誤和建議，請各位大佬盡情留言！如果這篇文章對你也有所幫助，希望可愛親切的您給個三連關注下，非常感謝啦！

相關文章