線程sleep，wait，notify，join，yield方法解析

線程的五種狀态

線程從建立到銷毀一般分為五種狀态，如下圖：

1） 建立

當用new關鍵字建立一個線程時，就是建立狀态。

2） 就緒

調用了 start 方法之後，線程就進入了就緒階段。此時，線程不會立即執行run方法，需要等待擷取CPU資源。

3） 運作

當線程獲得CPU時間片後，就會進入運作狀态，開始執行run方法。

4） 阻塞

當遇到以下幾種情況，線程會從運作狀态進入到阻塞狀态。

• 調用sleep方法，使線程睡眠。
• 調用wait方法，使線程進入等待。
• 當線程去擷取同步鎖的時候，鎖正在被其他線程持有。
• 調用阻塞式IO方法時會導緻線程阻塞。
• 調用suspend方法，挂起線程，也會造成阻塞。

需要注意的是，阻塞狀态隻能進入就緒狀态，不能直接進入運作狀态。因為，從就緒狀态到運作狀态的切換是不受線程自己控制的，而是由線程排程器所決定。隻有當線程獲得了CPU時間片之後，才會進入運作狀态。

5） 死亡

當run方法正常執行結束時，或者由于某種原因抛出異常都會使線程進入死亡狀态。另外，直接調用stop方法也會停止線程。但是，此方法已經被棄用，不推薦使用。

線程常用方法

1）sleep

當調用 Thread.sleep(long millis) 睡眠方法時，就會使目前線程進入阻塞狀态。millis參數指定了線程睡眠的時間，機關是毫秒。 當時間結束之後，線程會重新進入就緒狀态。

注意，如果目前線程獲得了一把同步鎖，則 sleep方法阻塞期間，是不會釋放鎖的。

2） wait、notify和notifyAll

首先，它們都是Object類中的方法。需要配合 Synchronized關鍵字來使用。

調用線程的wait方法會使目前線程等待，直到其它線程調用此對象的notify/notifyAll方法。 如果，目前對象鎖有N個線程在等待，則notify方法會随機喚醒其中一個線程，而notifyAll會喚醒對象鎖中所有的線程。需要注意，喚醒時，不會立馬釋放鎖，隻有目前線程執行完之後，才會把鎖釋放。

另外，wait方法和sleep方法不同之處，在于sleep方法不會釋放鎖，而wait方法會釋放鎖。wait、notify的使用如下：

public class WaitTest {
    private static Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        ListAdd listAdd = new ListAdd();

        Thread t1 = new Thread(() -> {
            synchronized (obj){
                try {
                    for (int i = 0; i < 10; i++) {
                        listAdd.add();
                        System.out.println("目前線程:"+Thread.currentThread().getName()+"添加了一個元素");
                        Thread.sleep(300);
                        if(listAdd.getSize() == 5){
                            System.out.println("發出通知");
                            obj.notify();
                        }
                    }
                } catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (obj){
                try {
                    if(listAdd.getSize() != 5){
                        obj.wait();
                    }
                } catch(InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println("線程:"+Thread.currentThread().getName()+"被通知.");
            }

        });

        t2.start();
        Thread.sleep(1000);
        t1.start();
    }
}

class ListAdd {
    private static volatile List<String> list = new ArrayList<String>();

    public void add() {
        list.add("abc");
    }

    public int getSize() {
        return list.size();
    }
}
      

以上，就是建立一個t2線程，判斷list長度是否為5，不是的話，就一直阻塞。然後，另外一個t1線程不停的向list中添加元素，當元素長度為5的時候，就去喚醒阻塞中的t2線程。

然而，我們會發現，此時的t1線程會繼續往下執行。直到方法執行完畢，才會把鎖釋放。t1線程去喚醒t2的時候，隻是讓t2具有參與鎖競争的資格。隻有t2真正獲得了鎖之後才會繼續往下執行。

3） join

當線程調用另外一個線程的join方法時，目前線程就會進入阻塞狀态。直到另外一個線程執行完畢，目前線程才會由阻塞狀态轉為就緒狀态。

或許，你在面試中，會被問到，怎麼才能保證t1，t2，t3線程按順序執行呢。（因為，我們知道，正常情況下，調用start方法之後，是不能控制線程的執行順序的）

咳咳，目前青澀的我，面試時就被問到這個問題，是一臉懵逼。其實，是非常簡單的，用join方法就可以輕松實作：

public class TestJoin {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new MultiT("a"));
        Thread t2 = new Thread(new MultiT("b"));
        Thread t3 = new Thread(new MultiT("c"));

        t1.start();
        t1.join();

        t2.start();
        t2.join();

        t3.start();
        t3.join();
    }

}

class MultiT implements Runnable{
    private String s;
    private int i;

    public MultiT(String s){
        this.s = s;
    }

    @Override
    public void run() {
        while(i<10){
            System.out.println(s+"===="+i++);
        }
    }
}
      

最終，我們會看到，線程會按照t1，t2，t3順序執行。因為，主線程main總會等調用join方法的那個線程執行完之後，才會往下執行。

4） yield

Thread.yield 方法會使目前線程放棄CPU時間片，把執行機會讓給相同或更高優先級的線程（yield英文意思就是屈服，放棄的意思嘛，可以了解為目前線程暫時屈服于别人了）。

注意，此時目前線程不會阻塞，隻是進入了就緒狀态，随時可以再次獲得CPU時間片，進而進入運作狀态。也就是說，其實yield方法，并不能保證，其它相同或更高優先級的線程一定會獲得執行權，也有可能，再次被目前線程拿到執行權。

yield方法和sleep方法一樣，也是不釋放鎖資源的。可以通過代碼來驗證這一點：

public class TestYield {
    public static void main(String[] args) {
        YieldThread yieldThread = new YieldThread();
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(yieldThread);
            t.start();
        }
    }
}

class YieldThread implements Runnable {

    private int count = 0;

    @Override
    public synchronized void run() {
        for (int i = 0; i < 10; i++) {
            count ++;
            if(count == 1){
                Thread.yield();
                System.out.println("線程:"+Thread.currentThread().getName() + "讓步");
            }
            System.out.println("線程:"+Thread.currentThread().getName() + ",count:"+count);
        }
    }
}
      

結果：

會看到，線程讓步之後，并不會釋放鎖。是以，其它線程也沒機會獲得鎖，隻能把目前線程執行完之後，才會釋放。（對于這一點，其實我是有疑問的。既然yield不釋放鎖，那為什麼還要放棄執行權呢。就算放棄了執行權，别的線程也無法獲得鎖啊。）

是以，我的了解，yield一般用于不存在鎖競争的多線程環境中。如果目前線程執行的任務時間可能比較長，就可以選擇用yield方法，暫時讓出CPU執行權。讓其它線程也有機會執行任務，而不至于讓CPU資源一直消耗在目前線程。

5）suspend、resume

suspend 會使線程挂起，并且不會自動恢複，隻有調用 resume 方法才能使線程進入就緒狀态。注意，這兩個方法由于有可能導緻死鎖，已經被廢棄。