前言

這幾天忙一點私事，今天回來趕緊把面試總結接著寫下去，這次來看看Thread的join（）方法和sleep（）和wait（）方法的區別。

正文

執行緒同步

上一篇提到了執行緒同步的問題，主要是通過鎖的形式來進行執行緒間的喚醒和等待，執行緒之間的協作都是很密切的，有些時候我們需要執行緒之間順序執行要怎麼做呢？？？

方法有很多，除了之前講過的以外，我所瞭解的還有兩種方法：

一、Thread的join()方法

join（）可以讓執行緒順序執行，他內部也是鎖的實現機制，看一下demo程式碼：

public class MainActivity extends AppCompatActivity
 
 {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        startFirstThread();
        startSecondThread();
        Log.e("lzp", "over");
    }

    private void startFirstThread(){
        Thread thread = new
 
 Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++){
                    Log.e("lzp", "first:"+ i);
                    if (i == 50){
                        try {
                            sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        };
        thread.start();
        try
 
 {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void startSecondThread(){
        Thread thread =  new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++){
                    Log.e("lzp", "second:"+ i);
                }
            }
        };
        thread.start();
    }
}

程式碼比較簡單，就是同時開啟了兩條執行緒，如果沒有沒有join方法的話，肯定這兩條執行緒是同時執行的，log的結果也是亂的。

然後在看一下第一條執行緒使用了join（）之後的結果，為了突出顯示顯示join的作用，我還在oncreate也輸入了一句over。

從log上來看，當第一條執行緒使用了join之後，主執行緒和第二條執行緒都暫停了，等待第一條執行緒執行完畢，在接著往下執行，說明呼叫了join之後，系統把所有的資源都給了第一條執行緒，就算是sleep（），也必要等待他執行完畢。

下面是第二條執行緒也join的結果：

所以join的作用就相當於阻塞掉除了當前執行緒以外的所有的執行緒（包括主執行緒），等待自己執行結束，並且遵守先來後到的排隊原則，先join的先執行，後join後執行，必須注意的是，最後的執行緒不能使用join，否則執行緒就全部在等待中，可以把最後一條不使用join的執行緒，當做此次排隊的結束。例如大家可以把demo中的oncreate中的最後的Log去掉，並且把第二條執行緒也join，看一下執行結果。

所以根據Thread的join（）方法的特性，可以實現執行緒的同步。

二、單執行緒池

SingleThreadExecutor：是單執行緒池，他保證在自己執行緒池中提交的執行緒，按照提交的順序，順序執行且同時只有一條執行緒在跑。

也就是他只能執行一條執行緒，執行完了再跑下一條，例如我們平時執行緒操作資料庫，防止多執行緒併發，就會經常使用SingleThreadExecutor。

那我們來修改一下程式碼：

public class MainActivity extends AppCompatActivity {

    /**
     * 單執行緒池
     * */
    private Executor executor = Executors.newSingleThreadExecutor();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        startFirstThread();
        startSecondThread();
        Log.e("lzp", "over");

    }

    private void startFirstThread(){
        executor.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++){
                    Log.e("lzp", "first:"+ i);
                    if (i == 50){
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });
    }

    private void startSecondThread(){
        executor.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++){
                    Log.e("lzp", "second:"+ i);
                }
            }
        });
    }
}

demo中順序提交了兩條執行緒，並且第一條執行緒還sleep了一秒，看一下執行結果：

執行緒1和執行緒2確實是順序執行的，就算是sleep也不行，但是同時也發現執行緒池不能把主執行緒的執行順序也包括進來，而這一點join可以做到。

ok，那執行緒同步就到此結束了，當然還有一些另類的方法，例如通過handler來發送訊息或者是其他的方法，這裡不做介紹了，需求是死的，但是套路是活的，有更好的方法，可以留言，大家一起交流。

sleep() 、wait（）的區別

這個問題當時是把我弄蒙圈了，因為我第一反應不知道為啥他倆要比較，因為覺得他倆好像沒多大的關係，後來在面試官的提示下我才明白他的意思，在這裡做個總結：

1、sleep（）屬於Thread，wait（）屬於 Class。

2、sleep（）僅僅是睡眠，不涉及到鎖的釋放問題，睡眠時間結束自動恢復到執行狀態。
wait（）綁定了某個物件的鎖，等待該物件的notify（），notifyAll（）來喚醒自己，等待的時間是未知的，甚至出現死鎖。

那sleep（）和wait（）會釋放cpu嗎？

這個問題在網上是五花八門，剛才我們已經使用了sleep（），就可以得到以下結論：

非執行緒池中
1、sleep（）中會釋放cpu，讓cpu去執行其他的執行緒，睡眠時間結束，在重新佔用cpu執行。（第一個demo的程式碼，執行緒1在睡眠中，直接把cpu交給了執行緒2）

2、如果呼叫了join方法（），相當於沒有釋放cpu，因為其他執行緒無法得到執行。（join方法的demo，順序執行，sleep無影響）。

執行緒池中
跟非執行緒池中一樣，會把資源讓給同時執行的執行緒，但是仍然會佔用執行緒池的位置，例如demo中的單執行緒池，儘管sleep，但是位置仍然佔用，所以下一個執行緒不會得到執行。

總結：無論怎用sleep都會釋放cpu，但是線上程池中會佔用位置。

那麼再來看看wait，wait跟sleep沒有太大差別，cpu肯定是要釋放出去的，那麼他會佔用執行緒池中的位置嗎？

修改一下程式碼：

private void startFirstThread(){
        executor.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++){
                    Log.e("lzp", "first:"+ i);
                    if (i == 50){
                        try {
                            synchronized (this){
                                wait();
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });
    }

我在第一個執行緒中，直接wait，看一下log：

log在50的時候停止了，第二條執行緒沒有執行，說明wait也會佔用執行緒池中的位置。

總結

首先我們聊了聊執行緒同步的問題，實現執行緒順序執行有很多種方法，就看大家自己的思考了，腦洞的同時也得思考合理性和實用性，好壞就不做評判了。

然後去討論一下sleep和wait的區別，總結：他倆都是要釋放cpu的，並且線上程池中會佔用位置。如果你也遇到了這樣的問題，就好辦多了。

OK，那這一篇就結束了，有什麼問題和建議歡迎留言。