wait()、notify()、notifyAll()是三個定義在Object類裡的方法，可以用來控制執行緒的狀態。

這三個方法最終呼叫的都是jvm級的native方法。隨著jvm執行平臺的不同可能有些許差異。
    如果物件呼叫了wait方法就會使持有該物件的執行緒把該物件的控制權交出去，然後處於等待狀態。
    如果物件呼叫了notify方法就會通知某個正在等待這個物件的控制權的執行緒可以繼續執行。
    如果物件呼叫了notifyAll方法就會通知所有等待這個物件控制權的執行緒繼續執行。

其中wait方法有三個over load方法：
wait()
wait(long)
wait(long,int)
wait方法通過引數可以指定等待的時長。如果沒有指定引數，預設一直等待直到被通知。

以下是一個演示程式碼，以最簡潔的方式說明覆雜的問題：
簡要說明下：
NotifyThread是用來模擬3秒鐘後通知其他等待狀態的執行緒的執行緒類；
WaitThread是用來模擬等待的執行緒類；
等待的中間物件是flag，一個String物件；
main方法中同時啟動一個Notify執行緒和三個wait執行緒；

    public class NotifyTest {  
        private  String flag = "true";  
      
        class NotifyThread extends Thread{  
            public NotifyThread(String name) {  
                super(name);  
            }  
            public void run() {       
                try {  
                    sleep(3000);//推遲3秒鐘通知  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                  
                    flag = "false";  
                    flag.notify();  
            }  
        };  
      
        class WaitThread extends Thread {  
            public WaitThread(String name) {  
                super(name);  
            }  
      
            public void run() {  
                  
                    while (flag!="false") {  
                        System.out.println(getName() + " begin waiting!");  
                        long waitTime = System.currentTimeMillis();  
                        try {  
                            flag.wait();  
                        } catch (InterruptedException e) {  
                            e.printStackTrace();  
                        }  
                        waitTime = System.currentTimeMillis() - waitTime;  
                        System.out.println("wait time :"+waitTime);  
                    }  
                    System.out.println(getName() + " end waiting!");  
                  
            }  
        }  
      
        public static void main(String[] args) throws InterruptedException {  
            System.out.println("Main Thread Run!");  
            NotifyTest test = new NotifyTest();  
            NotifyThread notifyThread =test.new NotifyThread("notify01");  
            WaitThread waitThread01 = test.new WaitThread("waiter01");  
            WaitThread waitThread02 = test.new WaitThread("waiter02");  
            WaitThread waitThread03 = test.new WaitThread("waiter03");  
            notifyThread.start();  
            waitThread01.start();  
            waitThread02.start();  
            waitThread03.start();  
        }  
      
    }
 

OK，如果你拿這段程式去執行下的話， 會發現根本執行不了，what happened？滿屏的java.lang.IllegalMonitorStateException。
沒錯，這段程式有很多問題，我們一個個來看。

首先，這兒要非常注意的幾個事實是
    任何一個時刻，物件的控制權（monitor）只能被一個執行緒擁有。
    無論是執行物件的wait、notify還是notifyAll方法，必須保證當前執行的執行緒取得了該物件的控制權（monitor）
    如果在沒有控制權的執行緒裡執行物件的以上三種方法，就會報java.lang.IllegalMonitorStateException異常。
    JVM基於多執行緒，預設情況下不能保證執行時執行緒的時序性

基於以上幾點事實，我們需要確保讓執行緒擁有物件的控制權。
也就是說在waitThread中執行wait方法時，要保證waitThread對flag有控制權；
在notifyThread中執行notify方法時，要保證notifyThread對flag有控制權。
執行緒取得控制權的方法有三：
    執行物件的某個同步例項方法。
    執行物件對應類的同步靜態方法。
    執行對該物件加同步鎖的同步塊。
我們用第三種方法來做說明：
將以上notify和wait方法包在同步塊中

synchronized (flag) {  
                flag = "false";  
                flag.notify();  
            }

synchronized (flag) {  
                while (flag!="false") {  
                    System.out.println(getName() + " begin waiting!");  
                    long waitTime = System.currentTimeMillis();  
                    try {  
                        flag.wait();  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                    waitTime = System.currentTimeMillis() - waitTime;  
                    System.out.println("wait time :"+waitTime);  
                }  
                System.out.println(getName() + " end waiting!");  
            }

我們向前進了一步。
問題解決了嗎？
好像執行還是報錯java.lang.IllegalMonitorStateException。what happened？

這時的異常是由於在針對flag物件同步塊中，更改了flag物件的狀態所導致的。如下：
flag=”false”;
flag.notify();
對在同步塊中對flag進行了賦值操作，使得flag引用的物件改變，這時候再呼叫notify方法時，因為沒有控制權所以丟擲異常。
我們可以改進一下，將flag改成一個JavaBean，然後更改它的屬性不會影響到flag的引用。
我們這裡改成陣列來試試，也可以達到同樣的效果：

這時候再執行，不再報異常，但是執行緒沒有結束是吧，沒錯，還有執行緒堵塞，處於wait狀態。
原因很簡單，我們有三個wait執行緒，只有一個notify執行緒，notify執行緒執行notify方法的時候，是隨機通知一個正在等待的執行緒，所以，現在應該還有兩個執行緒在waiting。
我們只需要將NotifyThread執行緒類中的flag.notify()方法改成notifyAll()就可以了。notifyAll方法會通知所有正在等待物件控制權的執行緒。
 最終完成版如下：

public class NotifyTest {  
    private String flag[] = { "true" };  
  
    class NotifyThread extends Thread {  
        public NotifyThread(String name) {  
            super(name);  
        }  
  
        public void run() {  
            try {  
                sleep(3000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            synchronized (flag) {  
                flag[0] = "false";  
                flag.notifyAll();  
            }  
        }  
    };  
  
    class WaitThread extends Thread {  
        public WaitThread(String name) {  
            super(name);  
        }  
  
        public void run() {  
            synchronized (flag) {  
                while (flag[0] != "false") {  
                    System.out.println(getName() + " begin waiting!");  
                    long waitTime = System.currentTimeMillis();  
                    try {  
                        flag.wait();  
  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                    waitTime = System.currentTimeMillis() - waitTime;  
                    System.out.println("wait time :" + waitTime);  
                }  
                System.out.println(getName() + " end waiting!");  
            }  
        }  
    }  
  
    public static void main(String[] args) throws InterruptedException {  
        System.out.println("Main Thread Run!");  
        NotifyTest test = new NotifyTest();  
        NotifyThread notifyThread = test.new NotifyThread("notify01");  
        WaitThread waitThread01 = test.new WaitThread("waiter01");  
        WaitThread waitThread02 = test.new WaitThread("waiter02");  
        WaitThread waitThread03 = test.new WaitThread("waiter03");  
        notifyThread.start();  
        waitThread01.start();  
        waitThread02.start();  
        waitThread03.start();  
    }  
  
}