對於，wait方法的解釋，有時候覺得很矛盾。呼叫某個物件的wait時，需要獲得該物件的鎖，在執行的時候又需要釋放該物件的所有鎖。這是問題一。

另外，在看Join的原始碼，會發現它利用了Wait來實現，但是它的實現原理是怎樣的呢？ 這是問題二。

看下原始碼的英文描述：

    * Causes the current thread to wait until either another thread invokes the notify()
     * method or the notifyAll()method for this object, or a  specified amount of time has elapsed.
     * <p>
     * The current thread must own this object's monitor

.
     * <p>
     * This method causes the current thread (call it <var>T</var>) to
     * place itself in the wait set for this object and then to relinquish
     * any and all synchronization claims on this object. Thread <var>T</var>
     * becomes disabled for thread scheduling purposes and lies dormant
     * until one of four things happens: 。。。。

看了許多文章，下面這篇文章解釋的很清楚。我先說說自己的總結。

很多方法都能Block執行緒，但是wait不一樣，它源自Object，意義是讓出佔有的鎖，又來等待它，可以理解成自己把自己放到等待佇列重新等該資源的情況。

當A執行緒呼叫某個資源的（例如a）wait的時候，需要a的資源，那麼再呼叫a的wait時，A需要有a，再得到a後，如果是wait(long l)的話，那麼A會自動放棄a資源l個時間，然後自己再來“搶”資源。如果是wait()的話，那麼A會一直等下去，除非有執行緒來notify了它或者notifyAll了所有等待的執行緒，A才會接著“搶”。

這種機制有利於解決死鎖的問題，即A在等待的同時，放棄自己佔有的資源。

理解這個後，Join方法就很好理解了。在A執行緒中，跑了個B執行緒，A想等B跑完後A再接著執行，那麼A可以呼叫B.join()方法，這樣B的鎖會先讓A拿到，然後join方法實際是呼叫wait方法，即B.wait()，那麼A又會放棄B資源，同時等B資源，直到B跑完後來notify A或者當有時間引數時，時間到了A接著來“搶”B資源。

下面這篇文章，有更多的詳細解釋。

-------------------------------------------------------------引用文章------------------------------------------------------- 

一個理解wait()與notify()的例子
原文連結：http://blog.csdn.net/xm4014/archive/2003/01/28/14714.aspx

下面是我原來在CSDN論壇上看到的一個貼子，涉及到同步,wait(),notify()等概念的理解，我試著根據原來的一些回覆和Think in Java上的相關概念將wait()和notify()這兩個方法剖析了一下，歡迎指教.

問題如下：

file://分析這段程式，並解釋一下，著重講講synchronized、wait(),notify 謝謝！
class ThreadA
{
   public static void main(String[] args)
   {
     ThreadB b=new ThreadB();
     b.start();
     System.out.println("b is start....");
     synchronized(b)//括號裡的b是什麼意思,起什麼作用?
     {
       try
       {
System.out.println("Waiting for b to complete...");
b.wait();//這一句是什麼意思，究竟讓誰wait?
         System.out.println("Completed.Now back to main thread");
       }catch (InterruptedException e){}
     }
     System.out.println("Total is :"+b.total);
    }
}

class ThreadB extends Thread
{
   int total;
   public void run()
   {
     synchronized(this)
     {
       System.out.println("ThreadB is running..");
       for (int i=0;i<100;i++ )
       {
         total +=i;
         System.out.println("total is "+total);
       }
       notify();
     }
   }
}

要分析這個程式,首先要理解notify()和wait(),為什麼在前幾天紀錄執行緒的時候沒有紀錄這兩個方法呢,因為這兩個方法本來就不屬於Thread類,而是屬於最底層的object基礎類的,也就是說不光是Thread，每個物件都有notify和wait的功能，為什麼？因為他們是用來操縱鎖的,而每個物件都有鎖,鎖是每個物件的基礎,既然鎖是基礎的,那麼操縱鎖的方法當然也是最基礎了.

再往下看之前呢,首先最好複習一下Think in Java的14.3.1中第3部分內容：等待和通知,也就是wait()和notify了.

按照Think in Java中的解釋:"wait()允許我們將執行緒置入“睡眠”狀態，同時又“積極”地等待條件發生改變.而且只有在一個notify()或notifyAll()發生變化的時候，執行緒才會被喚醒，並檢查條件是否有變."

   我們來解釋一下這句話.
   "wait()允許我們將執行緒置入“睡眠”狀態",也就是說,wait也是讓當前執行緒阻塞的,這一點和sleep或者suspend是相同的.那和sleep,suspend有什麼區別呢?

    區別在於"(wait)同時又“積極”地等待條件發生改變",這一點很關鍵,sleep和suspend無法做到.因為我們有時候需要通過同步（synchronized）的幫助來防止執行緒之間的衝突，而一旦使用同步,就要鎖定物件，也就是獲取物件鎖,其它要使用該物件鎖的執行緒都只能排隊等著,等到同步方法或者同步塊裡的程式全部執行完才有機會.在同步方法和同步塊中,無論sleep()還是suspend()都不可能自己被呼叫的時候解除鎖定,他們都霸佔著正在使用的物件鎖不放.
    而wait卻可以,它可以讓同步方法或者同步塊暫時放棄物件鎖,而將它暫時讓給其它需要物件鎖的人(這裡應該是程式塊,或執行緒)用,這意味著可在執行wait()期間呼叫執行緒物件中的其他同步方法!在其它情況下(sleep啊,suspend啊),這是不可能的.
    但是注意我前面說的,只是暫時放棄物件鎖,暫時給其它執行緒使用,我wait所在的執行緒還是要把這個物件鎖收回來的呀.wait什麼?就是wait別人用完了還給我啊！
    好,那怎麼把物件鎖收回來呢?
    第一種方法,限定借出去的時間.在wait()中設定引數,比如wait(1000),以毫秒為單位,就表明我只借出去1秒中,一秒鐘之後,我自動收回.
    第二種方法,讓借出去的人通知我,他用完了,要還給我了.這時,我馬上就收回來.哎,假如我設了1小時之後收回,別人只用了半小時就完了,那怎麼辦呢?靠!當然用完了就收回了,還管我設的是多長時間啊.

    那麼別人怎麼通知我呢?相信大家都可以想到了,notify(),這就是最後一句話"而且只有在一個notify()或notifyAll()發生變化的時候，執行緒才會被喚醒"的意思了.
    因此,我們可將一個wait()和notify()置入任何同步方法或同步塊內部，無論在那個類裡是否準備進行涉及執行緒的處理。而且實際上,我們也只能在同步方法或者同步塊裡面呼叫wait()和notify().

    這個時候我們來解釋上面的程式,簡直是易如反掌了.

    synchronized(b){...}；的意思是定義一個同步塊,使用b作為資源鎖。b.wait();的意思是臨時釋放鎖，並阻塞當前執行緒,好讓其他使用同一把鎖的執行緒有機會執行,在這裡要用同一把鎖的就是b執行緒本身.這個執行緒在執行到一定地方後用notify()通知wait的執行緒,鎖已經用完,待notify()所在的同步塊執行完之後,wait所在的執行緒就可以繼續執行.

java多執行緒設計wait/notify機制

多執行緒之間需要協調工作。例如，瀏覽器的一個顯示圖片的執行緒displayThread想要執行顯示圖片的任務，必須等待下載執行緒downloadThread將該圖片下載完畢。如果圖片還沒有下載完，displayThread可以暫停，當downloadThread完成了任務後，再通知displayThread“圖片準備完畢，可以顯示了”，這時，displayThread繼續執行。

以上邏輯簡單的說就是：如果條件不滿足，則等待。當條件滿足時，等待該條件的執行緒將被喚醒。在Java中，這個機制的實現依賴於wait/notify。等待機制與鎖機制是密切關聯的。例如：

synchronized(obj) {
     while(!condition) {
         obj.wait();
     }
     obj.doSomething();
}

當執行緒A獲得了obj鎖後，發現條件condition不滿足，無法繼續下一處理，於是執行緒A就wait()。

在另一執行緒B中，如果B更改了某些條件，使得執行緒A的condition條件滿足了，就可以喚醒執行緒A：

synchronized(obj) {
     condition = true;
     obj.notify();
}

需要注意的概念是：

# 呼叫obj的wait(), notify()方法前，必須獲得obj鎖，也就是必須寫在synchronized(obj) {...} 程式碼段內。

# 呼叫obj.wait()後，執行緒A就釋放了obj的鎖，否則執行緒B無法獲得obj鎖，也就無法在synchronized(obj) {...} 程式碼段內喚醒A。

# 當obj.wait()方法返回後，執行緒A需要再次獲得obj鎖，才能繼續執行。

# 如果A1,A2,A3都在obj.wait()，則B呼叫obj.notify()只能喚醒A1,A2,A3中的一個（具體哪一個由JVM決定）。

# obj.notifyAll()則能全部喚醒A1,A2,A3，但是要繼續執行obj.wait()的下一條語句，必須獲得obj鎖，因此，A1,A2,A3只有一個有機會獲得鎖繼續執行，例如A1，其餘的需要等待A1釋放obj鎖之後才能繼續執行。

# 當B呼叫obj.notify/notifyAll的時候，B正持有obj鎖，因此，A1,A2,A3雖被喚醒，但是仍無法獲得obj鎖。直到B退出synchronized塊，釋放obj鎖後，A1,A2,A3中的一個才有機會獲得鎖繼續執行。

synchronized的4種用法

1.方法宣告時使用,放在範圍操作符(public等)之後,返回型別宣告(void等)之前.即一次只能有一個執行緒進入該方法,其他執行緒要想在此時呼叫該方法,只能排隊等候,當前執行緒(就是在synchronized方法內部的執行緒)執行完該方法後,別的執行緒才能進入.

       例如:

       public synchronized void synMethod() {
         //方法體
       }

     2.對某一程式碼塊使用,synchronized後跟括號,括號裡是變數,這樣,一次只有一個執行緒進入該程式碼塊.例如:

       public int synMethod(int a1){
         synchronized(a1) {
           //一次只能有一個執行緒進入
         }
       }
     3.synchronized後面括號裡是一物件,此時,執行緒獲得的是物件鎖.例如:

public class MyThread implements Runnable {
   public static void main(String args[]) {
     MyThread mt = new MyThread();
     Thread t1 = new Thread(mt, "t1");
     Thread t2 = new Thread(mt, "t2");
     Thread t3 = new Thread(mt, "t3");
     Thread t4 = new Thread(mt, "t4");
     Thread t5 = new Thread(mt, "t5");
     Thread t6 = new Thread(mt, "t6");
     t1.start();
     t2.start();
     t3.start();
     t4.start();
     t5.start();
     t6.start();
   }

   public void run() {
     synchronized (this) {
       System.out.println(Thread.currentThread().getName());
     }
   }
}

     對於3,如果執行緒進入,則得到物件鎖,那麼別的執行緒在該類所有物件上的任何操作都不能進行.在物件級使用鎖通常是一種比較粗糙的方法。為什麼要將整個物件都上鎖，而不允許其他執行緒短暫地使用物件中其他同步方法來訪問共享資源？如果一個物件擁有多個資源，就不需要只為了讓一個執行緒使用其中一部分資源，就將所有執行緒都鎖在外面。由於每個物件都有鎖，可以如下所示使用虛擬物件來上鎖：

class FineGrainLock {

    MyMemberClass x, y;
    Object xlock = new Object(), ylock = new Object();

    public void foo() {
       synchronized(xlock) {
          //access x here
       }

       //do something here - but don't use shared resources

       synchronized(ylock) {
          //access y here
       }
    }

    public void bar() {
       synchronized(this) {
          //access both x and y here
       }
       //do something here - but don't use shared resources
    }
}

     4.synchronized後面括號裡是類.例如:

class ArrayWithLockOrder{
   private static long num_locks = 0;
   private long lock_order;
   private int[] arr;

   public ArrayWithLockOrder(int[] a)
   {
     arr = a;
     synchronized(ArrayWithLockOrder.class) {//-----------------------------------------這裡
       num_locks++;              // 鎖數加 1。
       lock_order = num_locks;   // 為此物件例項設定唯一的 lock_order。
     }
   }
   public long lockOrder()
   {
     return lock_order;
   }
   public int[] array()
   {
     return arr;
   }
}

class SomeClass implements Runnable
{
   public int sumArrays(ArrayWithLockOrder a1,
                        ArrayWithLockOrder a2)
   {
     int value = 0;
     ArrayWithLockOrder first = a1;        // 保留陣列引用的一個
     ArrayWithLockOrder last = a2;         // 本地副本。
     int size = a1.array().length;
     if (size == a2.array().length)
     {
       if (a1.lockOrder() > a2.lockOrder())   // 確定並設定物件的鎖定
       {                                      // 順序。
         first = a2;
         last = a1;
       }
       synchronized(first) {               // 按正確的順序鎖定物件。
         synchronized(last) {
           int[] arr1 = a1.array();
           int[] arr2 = a2.array();
           for (int i=0; i             value += arr1[i] + arr2[i];
         }
       }
     }
     return value;
   }
   public void run() {
     //...
   }
}

     對於4,如果執行緒進入,則執行緒在該類中所有操作不能進行,包括靜態變數和靜態方法,實際上,對於含有靜態方法和靜態變數的程式碼塊的同步,我們通常用4來加鎖.

以上4種之間的關係：

     鎖是和物件相關聯的，每個物件有一把鎖，為了執行synchronized語句，執行緒必須能夠獲得synchronized語句中表達式指定的物件的鎖，一個物件只有一把鎖，被一個執行緒獲得之後它就不再擁有這把鎖，執行緒在執行完synchronized語句後，將獲得鎖交還給物件。
    在方法前面加上synchronized修飾符即可以將一個方法宣告為同步化方法。同步化方法在執行之前獲得一個鎖。如果這是一個類方法，那麼獲得的鎖是和宣告方法的類相關的Class類物件的鎖。如果這是一個例項方法，那麼此鎖是this物件的鎖。

   下面談一談一些常用的方法:

   wait(),wait(long),notify(),notifyAll()等方法是當前類的例項方法,
    
         wait()是使持有物件鎖的執行緒釋放鎖;
         wait(long)是使持有物件鎖的執行緒釋放鎖時間為long(毫秒)後,再次獲得鎖,wait()和wait(0)等價;
         notify()是喚醒一個正在等待該物件鎖的執行緒,如果等待的執行緒不止一個,那麼被喚醒的執行緒由jvm確定;
         notifyAll是喚醒所有正在等待該物件鎖的執行緒.
         在這裡我也重申一下,我們應該優先使用notifyAll()方法,因為喚醒所有執行緒比喚醒一個執行緒更容易讓jvm找到最適合被喚醒的執行緒.

     對於上述方法,只有在當前執行緒中才能使用,否則報執行時錯誤java.lang.IllegalMonitorStateException: current thread not owner.

     下面,我談一下synchronized和wait()、notify()等的關係:

1.有synchronized的地方不一定有wait,notify

2.有wait,notify的地方必有synchronized.這是因為wait和notify不是屬於執行緒類，而是每一個物件都具有的方法，而且，這兩個方法都和物件鎖有關，有鎖的地方，必有synchronized。

另外，請注意一點：如果要把notify和wait方法放在一起用的話，必須先呼叫notify後呼叫wait，因為如果呼叫完wait，該執行緒就已經不是current thread了。如下例：

/**
* Title:         Jdeveloper's Java Projdect
* Description:   n/a
* Copyright:     Copyright (c) 2001
* Company:       soho  http://www.ChinaJavaWorld.com
* @author [email protected]
* @version 1.0
*/
import java.lang.Runnable;
import java.lang.Thread;

public class DemoThread
     implements Runnable {

   public DemoThread() {
     TestThread testthread1 = new TestThread(this, "1");
     TestThread testthread2 = new TestThread(this, "2");

     testthread2.start();
     testthread1.start();

   }

   public static void main(String[] args) {
     DemoThread demoThread1 = new DemoThread();

   }

   public void run() {

     TestThread t = (TestThread) Thread.currentThread();
     try {
       if (!t.getName().equalsIgnoreCase("1")) {
         synchronized (this) {
           wait();
         }
       }
       while (true) {

         System.out.println("@time in thread" + t.getName() + "=" +
                            t.increaseTime());

         if (t.getTime() % 10 == 0) {
           synchronized (this) {
             System.out.println("****************************************");
             notify();
             if (t.getTime() == 100)
               break;
             wait();
           }
         }
       }
     }
     catch (Exception e) {
       e.printStackTrace();
     }
   }

}

class TestThread
     extends Thread {
   private int time = 0;
   public TestThread(Runnable r, String name) {
     super(r, name);
   }

   public int getTime() {
     return time;
   }

   public int increaseTime() {
     return++time;
   }

}

     下面我們用生產者/消費者這個例子來說明他們之間的關係:

     public class test {
   public static void main(String args[]) {
     Semaphore s = new Semaphore(1);
     Thread t1 = new Thread(s, "producer1");
     Thread t2 = new Thread(s, "producer2");
     Thread t3 = new Thread(s, "producer3");
     Thread t4 = new Thread(s, "consumer1");
     Thread t5 = new Thread(s, "consumer2");
     Thread t6 = new Thread(s, "consumer3");
     t1.start();
     t2.start();
     t3.start();
     t4.start();
     t5.start();
     t6.start();
   }
}

class Semaphore
     implements Runnable {
   private int count;
   public Semaphore(int n) {
     this.count = n;
   }

   public synchronized void acquire() {
     while (count == 0) {
       try {
         wait();
       }
       catch (InterruptedException e) {
         //keep trying
       }
     }
     count--;
   }

   public synchronized void release() {
     while (count == 10) {
       try {
         wait();
       }
       catch (InterruptedException e) {
         //keep trying
       }
     }
     count++;
     notifyAll(); //alert a thread that's blocking on this semaphore
   }

   public void run() {
     while (true) {
       if (Thread.currentThread().getName().substring(0,8).equalsIgnoreCase("consumer")) {
         acquire();
       }
       else if (Thread.currentThread().getName().substring(0,8).equalsIgnoreCase("producer")) {
         release();
       }
       System.out.println(Thread.currentThread().getName() + " " + count);
     }
   }
}

        生產者生產,消費者消費,一般沒有衝突,但當庫存為0時,消費者要消費是不行的,但當庫存為上限(這裡是10)時,生產者也不能生產.請好好研讀上面的程式,你一定會比以前進步很多.

       上面的程式碼說明了synchronized和wait,notify沒有絕對的關係,在synchronized宣告的方法、程式碼塊中,你完全可以不用wait,notify等方法,但是,如果當執行緒對某一資源存在某種爭用的情況下,你必須適時得將執行緒放入等待或者喚醒.