Java監視器支持兩種線程：互斥和協作。

前面我們介紹了采用對象鎖和重入鎖來實現的互斥。這一篇中，我們來看一看線程的協作。

舉個例子：有一家漢堡店舉辦吃漢堡比賽，決賽時有3個顧客來吃，3個廚師來做，一個服務員負責協調漢堡的數量。為了避免浪費，制作好的漢堡被放進一個能裝有10個漢堡的長條狀容器中，按照先進先出的原則取漢堡。如果容器被裝滿，則廚師停止做漢堡，如果顧客發現容器內的漢堡吃完了，就可以拍響容器上的鬧鈴，提醒廚師再做幾個漢堡出來。此時服務員過來安撫顧客，讓他等待。而一旦廚師的漢堡做出來，就會讓服務員通知顧客，漢堡做好了，讓顧客繼續過來取漢堡。

這里，顧客其實就是我們所說的消費者，而廚師就是生產者。容器是決定廚師行為的監視器，而服務員則負責監視顧客的行為。

在JVM中，此種監視器被稱為等待并喚醒監視器。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
在這種監視器中，一個已經持有該監視器的線程，可以通過調用監視對象的wait方法，暫停自身的執行，并釋放監視器，自己進入一個等待區，直到監視器內的其他線程調用了監視對象的notify方法。當一個線程調用喚醒命令以后，它會持續持有監視器，直到它主動釋放監視器。而這之后，等待線程會蘇醒，其中的一個會重新獲得監視器，判斷條件狀態，以便決定是否繼續進入等待狀態或者執行監視區域，或者退出。

請看下面的代碼：

   1. public class NotifyTest { 
   2.     private  String flag = "true"; 
   3.  
   4.     class NotifyThread extends Thread{ 
   5.         public NotifyThread(String name) { 
   6.             super(name); 
   7.         } 
   8.         public void run() {      
   9.             try { 
  10.                 sleep(3000);//推遲3秒鐘通知 
  11.             } catch (InterruptedException e) { 
  12.                 e.printStackTrace(); 
  13.             } 
  14.              
  15.                 flag = "false"; 
  16.                 flag.notify(); 
  17.         } 
  18.     }; 
  19.  
  20.     class WaitThread extends Thread { 
  21.         public WaitThread(String name) { 
  22.             super(name); 
  23.         } 
  24.  
  25.         public void run() { 
  26.              
  27.                 while (flag!="false") { 
  28.                     System.out.println(getName() + " begin waiting!"); 
  29.                     long waitTime = System.currentTimeMillis(); 
  30.                     try { 
  31.                         flag.wait(); 
  32.                     } catch (InterruptedException e) { 
  33.                         e.printStackTrace(); 
  34.                     } 
  35.                     waitTime = System.currentTimeMillis() - waitTime; 
  36.                     System.out.println("wait time :"+waitTime); 
  37.                 } 
  38.                 System.out.println(getName() + " end waiting!"); 
  39.              
  40.         } 
  41.     } 
  42.  
  43.     public static void main(String[] args) throws InterruptedException { 
  44.         System.out.println("Main Thread Run!"); 
  45.         NotifyTest test = new NotifyTest(); 
  46.         NotifyThread notifyThread =test.new NotifyThread("notify01"); 
  47.         WaitThread waitThread01 = test.new WaitThread("waiter01"); 
  48.         WaitThread waitThread02 = test.new WaitThread("waiter02"); 
  49.         WaitThread waitThread03 = test.new WaitThread("waiter03"); 
  50.         notifyThread.start(); 
  51.         waitThread01.start(); 
  52.         waitThread02.start(); 
  53.         waitThread03.start(); 
  54.     } 
  55.  
  56. } 

轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
這段代碼啟動了三個簡單的wait線程，當他們處于等待狀態以后，試圖由一個notify線程來喚醒。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
運行這段程序，你會發現，滿屏的java.lang.IllegalMonitorStateException，根本不是你想要的結果。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
請注意以下幾個事實：
   1. 任何一個時刻，對象的控制權（monitor）只能被一個線程擁有。
   2. 無論是執行對象的wait、notify還是notifyAll方法，必須保證當前運行的線程取得了該對象的控制權（monitor）。
   3. 如果在沒有控制權的線程里執行對象的以上三種方法，就會報java.lang.IllegalMonitorStateException異常。
   4. JVM基于多線程，默認情況下不能保證運行時線程的時序性。

也就是說，當線程在調用某個對象的wait或者notify方法的時候，要先取得該對象的控制權，換句話說，就是進入這個對象的監視器。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
通過前面對同步的討論，我們知道，要讓一個線程進入某個對象的監視器，通常有三種方法：
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
1： 執行對象的某個同步實例方法
2： 執行對象對應的同步靜態方法
3： 執行對該對象加同步鎖的同步塊

顯然，在上面的例程中，我們用第三種方法比較合適。

于是我們將上面的wait和notify方法調用包在同步塊中。

   1.             synchronized (flag) { 
   2.                 flag = "false"; 
   3.                 flag.notify(); 
   4.             } 

轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
   1.             synchronized (flag) { 
   2.                 while (flag!="false") { 
   3.                     System.out.println(getName() + " begin waiting!"); 
   4.                     long waitTime = System.currentTimeMillis(); 
   5.                     try { 
   6.                         flag.wait(); 
   7.                     } catch (InterruptedException e) { 
   8.                         e.printStackTrace(); 
   9.                     } 
  10.                     waitTime = System.currentTimeMillis() - waitTime; 
  11.                     System.out.println("wait time :"+waitTime); 
  12.                 } 
  13.                 System.out.println(getName() + " end waiting!"); 
  14.             } 



但是，運行這個程序，我們發現事與愿違。那個非法監視器異常又出現了。。。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
我們注意到，針對flag的同步塊中，我們實際上已經更改了flag對對象的引用： flag="false";
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
顯然，這樣一來，同步塊也無能為力了，因為我們根本不是針對唯一的一個對象在進行同步。

我們不妨將flag封裝到JavaBean或者數組中去，這樣用JavaBean對象或者數組對象進行同步，就可以達到既能修改里面參數又不耽誤同步的目的。

1. private   String flag[] = {"true"};


   1.         synchronized (flag) { 
   2.             flag[0] = "false"; 
   3.             flag.notify(); 
   4.         } 



   1.                  synchronized (flag) { 
   2.                 flag[0] = "false"; 
   3.                 flag.notify(); 
   4.             }synchronized (flag) { 
   5.                 while (flag[0]!="false") { 
   6.                     System.out.println(getName() + " begin waiting!"); 
   7.                     long waitTime = System.currentTimeMillis(); 
   8.                     try { 
   9.                         flag.wait(); 
  10.                          
  11.                     } catch (InterruptedException e) { 
  12.                         e.printStackTrace(); 
  13.                     } 


運行這個程序，看不到異常了。但是仔細觀察結果，貌似只有一個線程被喚醒。利用jconsole等工具查看線程狀態，發現的確還是有兩個線程被阻塞的。這是為啥呢？

程序中使用了flag.notify()方法。只能是隨機的喚醒一個線程。我們可以改用flag.notifyAll()方法。這樣，所有被阻塞的線程都會被喚醒了。

最終代碼請讀者自己修改，這里不再贅述。

好了，親愛的讀者們，讓我們回到開篇提到的漢堡店大賽問題當中去，來看一看廚師、服務生和顧客是怎么協作進行這個比賽的。

首先我們構造故事中的三個次要對象：漢堡包、存放漢堡包的容器、服務生

public class Waiter {//服務生，這是個配角，不需要屬性。
}

    class Hamberg {
        //漢堡包
        private int id;//漢堡編號
        private String cookerid;//廚師編號
        public Hamberg(int id, String cookerid){
            this.id = id;
            this.cookerid = cookerid;
            System.out.println(this.toString()+"was made!");
        }

        @Override
        public String toString() {
            return "#"+id+" by "+cookerid;
        }
        
    }

    class HambergFifo {
        //漢堡包容器
        List<Hamberg> hambergs = new ArrayList<Hamberg>();//借助ArrayList來存放漢堡包
        int maxSize = 10;//指定容器容量

        //放入漢堡
        public <T extends Hamberg> void push(T t) {
            hambergs.add(t);
        }

        //取出漢堡
        public Hamberg pop() {
            Hamberg h = hambergs.get(0);
            hambergs.remove(0);
            return h;
        }

        //判斷容器是否為空
        public synchronized boolean isEmpty() {
            return hambergs.isEmpty();
        }

        //判斷容器內漢堡的個數
        public synchronized int size() {
            return hambergs.size();
        }

        //返回容器的最大容量
        public synchronized int getMaxSize() {
            return this.maxSize;
        }

        //判斷容器是否已滿，未滿為真
        public synchronized boolean isNotFull(){
            return hambergs.size() < this.maxSize;
        }
    }

接下來我們構造廚師對象：

    class Cooker implements Runnable {
        //廚師要面對容器
        HambergFifo pool;
        //還要面對服務生
        Waiter waiter;

        public Cooker(Waiter waiter, HambergFifo hambergStack) {
            this.pool = hambergStack;
            this.waiter = waiter;
        }
        //制造漢堡
        public void makeHamberg() {
            //制造的個數
            int madeCount = 0;
            //因為容器滿，被迫等待的次數
            int fullFiredCount = 0;
            try {
                
                while (true) {
                    //制作漢堡前的準備工作
                    Thread.sleep(1000);
                    if (pool.isNotFull()) {
                        synchronized (waiter) {
                            //容器未滿，制作漢堡，并放入容器。
                            pool.push(new Hamberg(++madeCount,Thread.currentThread().getName()));
                            //說出容器內漢堡數量
                            System.out.println(Thread.currentThread().getName() + ": There are "
                                          + pool.size() + " Hambergs in all");
                            //讓服務生通知顧客，有漢堡可以吃了
                            waiter.notifyAll();
                            System.out.println("### Cooker: waiter.notifyAll() :"+
                                      " Hi! Customers, we got some new Hambergs!");
                        }
                    } else {
                        synchronized (pool) {
                            if (fullFiredCount++ < 10) {
                                //發現容器滿了，停止做漢堡的嘗試。
                                System.out.println(Thread.currentThread().getName() +
                                        ": Hamberg Pool is Full, Stop making hamberg");
                                System.out.println("### Cooker: pool.wait()");
                                //漢堡容器的狀況使廚師等待
                                pool.wait();
                            } else {
                                return;
                            }
                        }

                    }
                    
                    //做完漢堡要進行收尾工作，為下一次的制作做準備。
                    Thread.sleep(1000);

                }
            } catch (Exception e) {
                madeCount--;
                e.printStackTrace();
            }
        }

        public void run() {

            makeHamberg();

        }
    }

接下來，我們構造顧客對象：

    class Customer implements Runnable {
        //顧客要面對服務生
        Waiter waiter;
        //也要面對漢堡包容器
        HambergFifo pool;
        //想要記下自己吃了多少漢堡
        int ateCount = 0;
        //吃每個漢堡的時間不盡相同
        long sleeptime;
        //用于產生隨機數
        Random r = new Random();

        public Customer(Waiter waiter, HambergFifo pool) {
            this.waiter = waiter;
            this.pool = pool;
        }

        public void run() {

            while (true) {

                try {
                    //取漢堡
                    getHamberg();
                    //吃漢堡
                    eatHamberg();
                } catch (Exception e) {
                    synchronized (waiter) {
                        System.out.println(e.getMessage());
                        //若取不到漢堡，要和服務生打交道
                        try {
                            System.out.println("### Customer: waiter.wait():"+
                                        " Sorry, Sir, there is no hambergs left, please wait!");
                            System.out.println(Thread.currentThread().getName()
                                        + ": OK, Waiting for new hambergs");
                            //服務生安撫顧客，讓他等待。
                            waiter.wait();
                            continue;
                        } catch (InterruptedException ex) {
                            ex.printStackTrace();
                        }
                    }
                }
            }
        }

        private void eatHamberg() {
            try {
                //吃每個漢堡的時間不等
                sleeptime = Math.abs(r.nextInt(3000)) * 5;
                System.out.println(Thread.currentThread().getName()
                        + ": I'm eating the hamberg for " + sleeptime + " milliseconds");
                
                Thread.sleep(sleeptime);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        private void getHamberg() throws Exception {
            Hamberg hamberg = null;

            synchronized (pool) {
                try {
                    //在容器內取漢堡
                    hamberg = pool.pop();

                    ateCount++;
                    System.out.println(Thread.currentThread().getName()
                               + ": I Got " + ateCount + " Hamberg " + hamberg);
                    System.out.println(Thread.currentThread().getName()
                                + ": There are still " + pool.size() + " hambergs left");


                } catch (Exception e) {
                    pool.notifyAll();
                    System.out.println("### Customer: pool.notifyAll()");
                    throw new Exception(Thread.currentThread().getName() +
                            ": OH MY GOD!!!! No hambergs left, Waiter![Ring the bell besides the hamberg pool]");

                }
            }
        }
    }

轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
最后，我們構造漢堡店，讓這個故事發生：
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
public class HambergShop {

    Waiter waiter = new Waiter();
    HambergFifo hambergPool = new HambergFifo();
    Customer c1 = new Customer(waiter, hambergPool);
    Customer c2 = new Customer(waiter, hambergPool);
    Customer c3 = new Customer(waiter, hambergPool);
    Cooker cooker = new Cooker(waiter, hambergPool);

    public static void main(String[] args) {
        HambergShop hambergShop = new HambergShop();
        Thread t1 = new Thread(hambergShop.c1, "Customer 1");
        Thread t2 = new Thread(hambergShop.c2, "Customer 2");
        Thread t3 = new Thread(hambergShop.c3, "Customer 3");
        Thread t4 = new Thread(hambergShop.cooker, "Cooker 1");
        Thread t5 = new Thread(hambergShop.cooker, "Cooker 2");
        Thread t6 = new Thread(hambergShop.cooker, "Cooker 3");
        t4.start();
        t5.start();
        t6.start();
        try {
            Thread.sleep(10000);
        } catch (Exception e) {
        }

        t1.start();
        t2.start();
        t3.start();
    }
}

運行這個程序吧，然后你會看到我們漢堡店的比賽進行的很好，只是不知道那些顧客是不是會被撐到。。。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
讀到這里，有的讀者可能會想到前面介紹的重入鎖ReentrantLock。
有的讀者會問：如果我用ReentrantLock來代替上面這些例程當中的 synchronized塊，是不是也可以呢？感興趣的讀者不妨一試。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
但是在這里，我想提前給出結論，就是，
如果用ReentrantLock的lock()和unlock()方法代替上面的synchronized塊，那么上面這些程序還是要拋出java.lang.IllegalMonitorStateException異常的，不僅如此，你甚至還會看到線程死鎖。原因就是當某個線程調用第三方對象的wait或者notify方法的時候，并沒有進入第三方對象的監視器，于是拋出了異常信息。但此時，程序流程如果沒有用finally來處理unlock方法，那么你的線程已經被lock方法上鎖，并且無法解鎖。程序在java.util.concurrent框架的語義級別死鎖了，你用JConsole這種工具來檢測JVM死鎖，還檢測不出來。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
正確的做法就是，只使用ReentrantLock，而不使用wait或者notify方法。因為ReentrantLock已經對這種互斥和協作進行了概括。所以，根據你程序的需要，請單獨采用重入鎖或者synchronized一種同步機制，最好不要混用。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/

好了，我們現在明白：轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
1. 線程的等待或者喚醒，并不是讓線程調用自己的wait或者notify方法，而是通過調用線程共享對象的wait或者notify方法來實現。
2. 線程要調用某個對象的wait或者notify方法，必須先取得該對象的監視器。
3. 線程的協作必須以線程的互斥為前提，這種協作實際上是一種互斥下的協作。
轉載注明出處：http://x- spirit.javaeye.com/、http: //www.tkk7.com/zhangwei217245/
下一講當中，我們來看看如何實實在在的解決線程之間搶占共享資源的問題。敬請期待！