1. 基本概念

在業(yè)務(wù)處理過程中，線程間常常需要進行通信，從而協(xié)同完成某個事項。比如，有兩個線程A和B，線程A負責讀取數(shù)據(jù)，線程B負責處理數(shù)據(jù)，線程A在讀取完數(shù)據(jù)后必須通知線程B進行數(shù)據(jù)處理，這個“通知”就是線程通信的表現(xiàn)。

2. 忙等待

怎樣實現(xiàn)線程通信呢？可以通過在線程間訪問一個共同的資源（標志位）來實現(xiàn)。比如線程A和線程B，線程A負責讀取數(shù)據(jù)，線程B負責處理數(shù)據(jù)。我們在A和B之間設(shè)置一個共同的資源：布爾值的Flag，標記A有沒有讀取完數(shù)據(jù)（默認為false，表示未讀取完數(shù)據(jù)）。我們讓B一直監(jiān)聽著這個Flag標記（使用while循環(huán)），當A讀取完數(shù)據(jù)后，會將這個Flag設(shè)為true，這時B監(jiān)聽到Flag變?yōu)閠rue了，就可以進行數(shù)據(jù)處理操作了。
簡要代碼如下：

public class SignalBusyWait {

    private volatile static Boolean flag = false;//共享資源，設(shè)置標志位
    public static void main(String[] args) {
        
        Thread A = new Thread(new Runnable() {//線程A，負責讀取數(shù)據(jù)，讀取完設(shè)置flag為true
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    System.out.println("讀取數(shù)據(jù)");
                    Thread.sleep(2000);
                    flag = true;
                    
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
        },"Thread A");
        
        Thread B = new Thread(new Runnable() {//線程B，負責處理數(shù)據(jù)，死循環(huán)監(jiān)聽flag
            @Override
            public void run() {
                // TODO Auto-generated method stub
                while(true){
                    if(flag){
                        System.out.println("處理數(shù)據(jù)");
                        break;//處理完數(shù)據(jù)，退出死循環(huán)
                    }else{
                        System.out.println("flag 為false，表示數(shù)據(jù)未讀取完，B線程進行等待");
                    }
                }
                
            }
        },"Thread B");
        B.start();
        A.start();
    }
}

以上方式雖然能夠?qū)崿F(xiàn)線程通信，但是B線程不斷地監(jiān)聽標志位，一直處理“等待”狀態(tài)，這就是忙等待現(xiàn)象。那么如何處理忙等待現(xiàn)象呢？Java提供了notify和wait機制。

3. notify，wait和notifyAll

Java給所有的對象都內(nèi)置了三個方法，用于線程通信。分別是notify，wait和notifyAll（這三個方法都是Object類的方法，Object類是所有Java類的父類，等于說所有Java對象都擁有了這三個方法）。

• 同一把鎖 : notify和wait方法必須使用同一監(jiān)聽對象（即競爭同一把鎖）。
• 就緒隊列和等待隊列：同一個監(jiān)聽對象上有兩個隊列，分別是就緒隊列和等待隊列。當線程不滿足執(zhí)行條件時（比如負責處理數(shù)據(jù)的B線程得到鎖后，發(fā)現(xiàn)數(shù)據(jù)還沒有讀取完，無法進行處理），就會進入等待隊列，等待執(zhí)行條件滿足時被喚醒。當線程被喚醒后并不是馬上執(zhí)行，而是進入就緒隊列，隨時準備好競爭鎖，獲得鎖后才能真正執(zhí)行。
• wait：當線程獲得鎖后發(fā)現(xiàn)執(zhí)行條件不滿足，這時候會調(diào)用wait方法，將這個線程加入到等待隊列中，并釋放鎖，讓其他就緒的線程可以再次競爭鎖。
• notify：當線程中調(diào)用notify方法時，當前線程并不會獲放鎖，當前線程會繼續(xù)執(zhí)行下去。它做的只是喚醒“等待隊列”中的一個線程，可以進入“就緒隊列”了。
• notifyAll: 與notify相同，只是它喚醒的是整個等待隊列中的所有線程。
  上面的代碼利用wait和notify實現(xiàn)如下：

public class NotifyWait {

    public final static Object monitorObject = new Object();//監(jiān)聽對象
    public static void main(String[] args) {
        
        Thread A = new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized(monitorObject){
                    try {
                        Thread.sleep(2000);
                        System.out.println("讀取數(shù)據(jù)");
                        monitorObject.notify();//讀取完數(shù)據(jù)，通知線程B處理數(shù)據(jù)
                        
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                
            }
        },"Thread A");
                
        Thread B = new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized(monitorObject){
                    try {
                        System.out.println("B線程獲得鎖，但發(fā)現(xiàn)數(shù)據(jù)未讀取完，進行等待");
                        monitorObject.wait();
                        Thread.sleep(2000);
                        System.out.println("處理數(shù)據(jù)");
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    
                }
            }
        },"Thread B");
        
        B.start();
        A.start();
        
    }
}

4. 使用wait和notify需要注意的問題

4.1 必須與synchronized關(guān)鍵字聯(lián)用

使用wait和notify進行通信時，必須與synchronized關(guān)鍵字結(jié)合使用，即必須在synchronized塊中調(diào)用wait和notify方法，才能夠保證同一時間只有一個線程發(fā)送信號。

4.2 信號丟失問題

有一種情況，當對象調(diào)用notify方法時，等待隊列中沒有線程，則沒有任何線程會收到這個信號，之后調(diào)用wait方法的線程將會一直等待，因為喚醒它的信號已經(jīng)丟失了。怎么辦呢，我們可以定義一個成員變量用來保存信號的狀態(tài)，然后在調(diào)用notify方法和wait方法前得到這個成員變量的值，判斷信號是否已經(jīng)發(fā)出，如以下代碼所示：

public class MyWaitNotify2{

  MonitorObject myMonitorObject = new MonitorObject();
  boolean wasSignalled = false;

  public void doWait(){
    synchronized(myMonitorObject){
      if(!wasSignalled){
        try{
          myMonitorObject.wait();
         } catch(InterruptedException e){...}
      }
      //clear signal and continue running.
      wasSignalled = false;
    }
  }

  public void doNotify(){
    synchronized(myMonitorObject){
      wasSignalled = true;
      myMonitorObject.notify();
    }
  }
}

我們定義了wasSingalled成員變量用來標示信號是否發(fā)出，這從一定程度上保證了信號不會丟失。

4.3 偽喚醒問題

上例中，有時候用于標示信號是否發(fā)出的標志位在監(jiān)聽對象并未調(diào)用notify方法時，就被修改成了true，從而導(dǎo)致本不該喚醒的進程被喚醒，喚醒的線程會繼續(xù)執(zhí)行后面的代碼，也就是所謂偽喚醒問題。我們可以將對標志位的判斷由if改為while，讓被喚醒的線程再判斷一次標志位，確定是否喚醒了正確的線程，從而避免偽喚醒問題。

4.4 不能使用字符串常量作為監(jiān)聽對象

注意，不能使用字符串常量作為監(jiān)聽對象，因為在JVM中是將字符串常量編譯到同一個對象的。舉個例子，當有兩個對象A和B都使用字符串常量（無論是否同一常量）作為監(jiān)聽對象，當對象A調(diào)用notify方法時，它可能會喚醒對象B等待隊列中的線程，從而造成混亂。