生產者與消費者（一）---wait與notify

生產者消費者問題是研究多線程程序時繞不開的經典問題之一，它描述是有一塊緩衝區做爲倉庫，生產者能夠將產品放入倉庫，消費者則能夠從倉庫中取走產品。解決生產者/消費者問題的方法可分爲兩類：

（1）採用某種機制保護生產者和消費者之間的同步；

（2）在生產者和消費者之間創建一個管道。

第一種方式有較高的效率，而且易於實現，代碼的可控制性較好，屬於經常使用的模式。第二種管道緩衝區不易控制，被傳輸數據對象不易於封裝等，實用性不強。所以本文只介紹同步機制實現的生產者/消費者問題。

同步問題核心在於：如何保證同一資源被多個線程併發訪問時的完整性。經常使用的同步方法是採用信號或加鎖機制，保證資源在任意時刻至多被一個線程訪問。Java語言在多線程編程上實現了徹底對象化，提供了對同步機制的良好支持。在Java中一共有四種方法支持同步，其中前三個是同步方法，一個是管道方法。

（1）wait() / notify()方法

（2）await() / signal()方法

（3）BlockingQueue阻塞隊列方法

（4）PipedInputStream / PipedOutputStream

本文先介紹第一種wait() / notify()方法，其餘三種後面再討論。

wait() / notify()方法

wait() / nofity()方法是基類Object的兩個方法，也就意味着全部Java類都會擁有這兩個方法，這樣，咱們就能夠爲任何對象實現同步機制。

wait()方法：當緩衝區已滿/空時，生產者/消費者線程中止本身的執行，放棄鎖，使本身處於等待狀態，讓其餘線程執行。

notify()方法：當生產者/消費者向緩衝區放入/取出一個產品時，向其餘等待的線程發出可執行的通知，同時放棄鎖，使本身處於等待狀態。

代碼示例：

緩衝區（倉庫）：

public class Storage {
    // 倉庫最大存儲量  
    private final int MAX_SIZE = 100;  
  
    // 倉庫存儲的載體  
    private LinkedList<Object> list = new LinkedList<Object>();  
  
    // 生產num個產品  
    public void produce(int num){  
        // 同步代碼段  
        synchronized (list){  
            // 若是倉庫剩餘容量不足  
            while (list.size() + num > MAX_SIZE){  
                System.out.println("【要生產的產品數量】:" + num + "/t【庫存量】:"+ list.size() + "/t暫時不能執行生產任務!");  
                try{  
                    // 因爲條件不知足，生產阻塞  
                    list.wait();  
                }  
                catch (InterruptedException e){  
                    e.printStackTrace();  
                }  
            }  
  
            // 倉庫剩餘容量充足，即生產條件知足狀況下，生產num個產品  
            for (int i = 1; i <= num; ++i){  
                list.add(new Object());  
            }  
  
            System.out.println("【已經生產產品數】:" + num + "/t【現倉儲量爲】:" + list.size());  
  
            list.notifyAll(); //生產完產品後，通知其餘被阻塞的線程 
        }  
    }  
  
    // 消費num個產品  
    public void consume(int num){  
        // 同步代碼段  
        synchronized (list){  
            // 若是倉庫存儲量不足  
            while (list.size() < num){  
                System.out.println("【要消費的產品數量】:" + num + "/t【庫存量】:"+ list.size() + "/t暫時不能執行消費任務!");  
                try{  
                    // 因爲條件不知足，消費阻塞  
                    list.wait();  
                }  
                catch (InterruptedException e)  
                {  
                    e.printStackTrace();  
                }  
            }  
  
            // 消費條件知足狀況下，消費num個產品  
            for (int i = 1; i <= num; ++i){  
                list.remove();  
            }  
  
            System.out.println("【已經消費產品數】:" + num + "/t【現倉儲量爲】:" + list.size());  
  
            list.notifyAll();//消費完後，釋放鎖，通知其餘被阻塞的線程  
        }  
    }  
  
    // get/set方法  
    public LinkedList<Object> getList(){  
        return list;  
    }  
  
    public void setList(LinkedList<Object> list){  
        this.list = list;  
    }  
  
    public int getMAX_SIZE(){  
        return MAX_SIZE;  
    }  
}

生產者：

public class Producer extends Thread {
    // 每次生產的產品數量  
    private int num;  
  
    // 所在放置的倉庫  
    private Storage storage;  
  
    // 構造函數，設置倉庫  
    public Producer(Storage storage){  
        this.storage = storage;  
    }  
  
    // 線程run函數  
    public void run(){  
        produce(num);  
    }  
  
    // 調用倉庫Storage的生產函數  
    public void produce(int num){  
        storage.produce(num);  
    }  
  
    // get/set方法  
    public int getNum()  
    {  
        return num;  
    }  
  
    public void setNum(int num)  
    {  
        this.num = num;  
    }  
  
    public Storage getStorage()  
    {  
        return storage;  
    }  
  
    public void setStorage(Storage storage)  
    {  
        this.storage = storage;  
    }  
    
}

消費者：

public class Consumer extends Thread {
    // 每次消費的產品數量  
    private int num;  
  
    // 所在放置的倉庫  
    private Storage storage;  
  
    // 構造函數，設置倉庫  
    public Consumer(Storage storage){  
        this.storage = storage;  
    }  
  
    // 線程run函數  
    public void run(){  
        consume(num);  
    }  
  
    // 調用倉庫Storage的生產函數  
    public void consume(int num){  
        storage.consume(num);  
    }  
  
    // get/set方法  
    public int getNum()  
    {  
        return num;  
    }  
  
    public void setNum(int num)  
    {  
        this.num = num;  
    }  
  
    public Storage getStorage()  
    {  
        return storage;  
    }  
  
    public void setStorage(Storage storage)  
    {  
        this.storage = storage;  
    }  
}

測試類：

public class Test {
    public static void main(String[] args) {
        // 倉庫對象  
        Storage storage = new Storage();  
  
        // 生產者對象  
        Producer p1 = new Producer(storage);  
        Producer p2 = new Producer(storage);  
        Producer p3 = new Producer(storage);  
        Producer p4 = new Producer(storage);  
        Producer p5 = new Producer(storage);  
        Producer p6 = new Producer(storage);  
        Producer p7 = new Producer(storage);  
  
        // 消費者對象  
        Consumer c1 = new Consumer(storage);  
        Consumer c2 = new Consumer(storage);  
        Consumer c3 = new Consumer(storage);  
  
        // 設置生產者產品生產數量  
        p1.setNum(10);  
        p2.setNum(10);  
        p3.setNum(10);  
        p4.setNum(10);  
        p5.setNum(10);  
        p6.setNum(10);  
        p7.setNum(80);  
  
        // 設置消費者產品消費數量  
        c1.setNum(50);  
        c2.setNum(20);  
        c3.setNum(30);  
  
        // 線程開始執行  
        c1.start();  
        c2.start();  
        c3.start();  
        p1.start();  
        p2.start();  
        p3.start();  
        p4.start();  
        p5.start();  
        p6.start();  
        p7.start();  
    }
}

你可能會對Storage類中爲何要定義public void produce(int num);和public void consume(int num);方法感到不解，爲何不直接在生產者類Producer和消費者類Consumer中實現這兩個方法，卻要調用Storage類中的實現呢？

由於若是在須要更新生產或者消費方法時，只須要更新倉庫類Storage的代碼便可，生產者Producer、消費者Consumer、測試類Test的代碼均不須要進行任何更改。這樣咱們就知道爲何要在Storage類中定義public void produce(int num);和public void consume(int num);方法，並在生產者類Producer和消費者類Consumer中調用Storage類中的實現了吧。將可能發生的變化集中到一個類中，不影響原有的構架設計，同時無需修改其餘業務層代碼。無心之中，好像使用了一種叫作策略模式的設計模式！