每日三道面試題，通往***的道路8——多線程

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

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

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

今天我們繼續聊聊多線程的話題吧！

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

接下來我們講一下：

start方法的作用：

啟動線程，相當于開啟一個線程調用我們重寫的run方法裡面的邏輯，此時相當于有兩個線程，一個main的主線程和開啟的子線程。可以看到我們的代碼，相當于有三個線程，一個主線程、一個Thread-0線程和一個Thread-1線程。并且線程之間是沒有順序的，他們是搶占cpu的資源來回切換的。
run方法的作用：

執行線程的運作時代碼，相當于我們隻是單純的調用一個普通方法。然後通過主線程的順序調用的方式，從myThread調用run方法結束後到myThread2去調用run方法結束，并且我們也可以看到我們控制台中的線程名字就是main主線程。
run方法我們可以重複調用，而start方法在一個線程中隻能調用一次。即myThread這個執行個體對象隻能調用一次start方法，如果再調用一次start方法的話，就會抛出 IllegalThreadStateException 的異常。
我們調用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)逾時後線程會自動蘇醒。

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

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