生產者消費者問題 簡介 生產者消費者模式並不是GOF提出的23種設計模式之一，23種設計模式都是建立在面向對象的基礎之上的，但其實面向過程的編程中也有很多高效的編程模式，生產者消費者模式便是其中之一，它是我們編程過程中最常用的一種設計模式。 在實際的軟體開發過程中，經常會碰到如下場景：某個模塊負責產 ...
簡介
生產者消費者模式並不是GOF提出的23種設計模式之一，23種設計模式都是建立在面向對象的基礎之上的，但其實面向過程的編程中也有很多高效的編程模式，生產者消費者模式便是其中之一，它是我們編程過程中最常用的一種設計模式。
在實際的軟體開發過程中，經常會碰到如下場景：某個模塊負責產生數據，這些數據由另一個模塊來負責處理（此處的模塊是廣義的，可以是類、函數、線程、進程等）。產生數據的模塊，就形象地稱為生產者；而處理數據的模塊，就稱為消費者。
單單抽象出生產者和消費者，還夠不上是生產者／消費者模式。該模式還需要有一個緩衝區處於生產者和消費者之間，作為一個中介。生產者把數據放入緩衝區，而消費者從緩衝區取出數據
為了不至於太抽象，我們舉一個寄信的例子（雖說這年頭寄信已經不時興，但這個例子還是比較貼切的）。假設你要寄一封平信，大致過程如下：
1、你把信寫好——相當於生產者製造數據
2、你把信放入郵筒——相當於生產者把數據放入緩衝區
3、郵遞員把信從郵筒取出——相當於消費者把數據取出緩衝區
4、郵遞員把信拿去郵局做相應的處理——相當於消費者處理數據
緩存區
緩存區的作用
解 耦
假設生產者和消費者分別是兩個類。如果讓生產者直接調用消費者的某個方法，那麼生產者對於消費者就會產生依賴（也就是耦合）。將來如果消費者的代碼發生變化，可能會影響到生產者。而如果兩者都依賴於某個緩衝區，兩者之間不直接依賴，耦合也就相應降低了。
接著上述的例子，如果不使用郵筒（也就是緩衝區），你必須得把信直接交給郵遞員。有同學會說，直接給郵遞員不是挺簡單的嘛？其實不簡單，你必須得認識誰是郵遞員，才能把信給他（光憑身上穿的制服，萬一有人假冒，就慘了）。這就產生和你和郵遞員之間的依賴（相當於生產者和消費者的強耦合）。萬一哪天郵遞員換人了，你還要重新認識一下（相當於消費者變化導致修改生產者代碼）。而郵筒相對來說比較固定，你依賴它的成本就比較低（相當於和緩衝區之間的弱耦合）。
支持併發（concurrency）
生產者直接調用消費者的某個方法，還有另一個弊端。由於函數調用是同步的（或者叫阻塞的），在消費者的方法沒有返回之前，生產者只好一直等在那邊。萬一消費者處理數據很慢，生產者就會白白糟蹋大好時光。
使用了生產者／消費者模式之後，生產者和消費者可以是兩個獨立的併發主體（常見併發類型有進程和線程兩種，後面的帖子會講兩種併發類型下的應用）。生產者把製造出來的數據往緩衝區一丟，就可以再去生產下一個數據。基本上不用依賴消費者的處理速度。
其實當初這個模式，主要就是用來處理併發問題的。
從寄信的例子來看。如果沒有郵筒，你得拿著信傻站在路口等郵遞員過來收（相當於生產者阻塞）；又或者郵遞員得挨家挨戶問，誰要寄信（相當於消費者輪詢）。不管是哪種方法，都挺土的。
支持忙閑不均
緩衝區還有另一個好處。如果製造數據的速度時快時慢，緩衝區的好處就體現出來了。當數據製造快的時候，消費者來不及處理，未處理的數據可以暫時存在緩衝區中。等生產者的製造速度慢下來，消費者再慢慢處理掉。
為了充分復用，我們再拿寄信的例子來說事。假設郵遞員一次只能帶走1000封信。萬一某次碰上情人節（也可能是聖誕節）送賀卡，需要寄出去的信超過1000封，這時候郵筒這個緩衝區就派上用場了。郵遞員把來不及帶走的信暫存在郵筒中，等下次過來時再拿走。
何謂數據單元捏？簡單地說，每次生產者放到緩衝區的，就是一個數據單元；每次消費者從緩衝區取出的，也是一個數據單元。對於前一個帖子中寄信的例子，我們可以把每一封單獨的信件看成是一個數據單元。
不過光這麼介紹，太過於簡單，無助於大伙兒分析出這玩意兒。所以，後面咱們來看一下數據單元需要具備哪些特性。搞明白這些特性之後，就容易從複雜的業務邏輯中分析出適合做數據單元的東西了。
數據單元的特性
分析數據單元，需要考慮如下幾個方面的特性：
關聯到業務對象
首先，數據單元必須關聯到某種業務對象。在考慮該問題的時候，你必須深刻理解當前這個生產者／消費者模式所對應的業務邏輯，才能夠作出合適的判斷。
由於“寄信”這個業務邏輯比較簡單，所以大伙兒很容易就可以判斷出數據單元是啥。但現實生活中，往往沒這麼樂觀。大多數業務邏輯都比較複雜，當中包含的業務對象是層次繁多、類型各異。在這種情況下，就不易作出決策了。
這一步很重要，如果選錯了業務對象，會導致後續程式設計和編碼實現的複雜度大為上升，增加了開發和維護成本。
完整性
所謂完整性，就是在傳輸過程中，要保證該數據單元的完整。要麼整個數據單元被傳遞到消費者，要麼完全沒有傳遞到消費者。不允許出現部分傳遞的情形。
對於寄信來說，你不能把半封信放入郵筒；同樣的，郵遞員從郵筒中拿信，也不能只拿出信的一部分。
獨立性
所謂獨立性，就是各個數據單元之間沒有互相依賴，某個數據單元傳輸失敗不應該影響已經完成傳輸的單元；也不應該影響尚未傳輸的單元。
為啥會出現傳輸失敗捏？假如生產者的生產速度在一段時間內一直超過消費者的處理速度，那就會導致緩衝區不斷增長並達到上限，之後的數據單元就會被丟棄。如果數據單元相互獨立，等到生產者的速度降下來之後，後續的數據單元繼續處理，不會受到牽連；反之，如果數據單元之間有某種耦合，導致被丟棄的數據單元會影響到後續其它單元的處理，那就會使程式邏輯變得非常複雜。
對於寄信來說，某封信弄丟了，不會影響後續信件的送達；當然更不會影響已經送達的信件。
顆粒度
前面提到，數據單元需要關聯到某種業務對象。那麼數據單元和業務對象是否要一一對應捏？很多場合確實是一一對應的。
不過，有時出於性能等因素的考慮，也可能會把N個業務對象打包成一個數據單元。那麼，這個N該如何取值就是顆粒度的考慮了。顆粒度的大小是有講究的。太大的顆粒度可能會造成某種浪費；太小的顆粒度可能會造成性能問題。顆粒度的權衡要基於多方面的因素，以及一些經驗值的考量。
還是拿寄信的例子。如果顆粒度過小（比如設定為1），那郵遞員每次只取出1封信。如果信件多了，那就得來回跑好多趟，浪費了時間。如果顆粒度太大（比如設定為100），那寄信的人得等到湊滿100封信才拿去放入郵筒。假如平時很少寫信，就得等上很久，也不太爽。
可能有同學會問：生產者和消費者的顆粒度能否設置成不同大小（比如對於寄信人設置成1，對於郵遞員設置成100）。當然，理論上可以這麼乾，但是在某些情況下會增加程式邏輯和代碼實現的複雜度。後面討論具體技術細節時，或許會聊到這個問題。
作者：生產者/消費者模式的理解及實現（整理） - Luego - 博客園 (cnblogs.com)
生產者消費者問題是研究多線程程式時繞不開的經典問題之一，它描述是有一塊緩衝區作為倉庫，生產者可以將產品放入倉庫，消費者則可以從倉庫中取走產品。解決生產者/消費者問題的方法可分為兩類：
（1）採用某種機制保護生產者和消費者之間的同步；
（2）在生產者和消費者之間建立一個管道。
第一種方式有較高的效率，並且易於實現，代碼的可控制性較好，屬於常用的模式。
第二種管道緩衝區不易控制，被傳輸數據對象不易於封裝等，實用性不強。因此本文只介紹同步機制實現的生產者/消費者問題。
同步問題核心在於：如何保證同一資源被多個線程併發訪問時的完整性。常用的同步方法是採用信號或加鎖機制，保證資源在任意時刻至多被一個線程訪問。Java語言在多線程編程上實現了完全對象化，提供了對同步機制的良好支持。在Java中一共有四種方法支持同步，其中前三個是同步方法，一個是管道方法。
（1）wait() / notify()方法
（2）await() / signal()方法
（3）BlockingQueue阻塞隊列方法
（4）PipedInputStream / PipedOutputStream
本文只介紹最常用的前三種，第四種暫不做討論，有興趣的讀者可以自己去網上找答案。
一、wait() / notify()方法
wait() / nofity()方法是基類Object的兩個方法，也就意味著所有Java類都會擁有這兩個方法，這樣，我們就可以為任何對象實現同步機制。
wait()方法：當緩衝區已滿/空時，生產者/消費者線程停止自己的執行，放棄鎖，使自己處於等等狀態，讓其他線程執行。
notify()方法：當生產者/消費者向緩衝區放入/取出一個產品時，向其他等待的線程發出可執行的通知，同時放棄鎖，使自己處於等待狀態。
光看文字可能不太好理解，咱來段代碼就明白了：
import java.util.LinkedList;
/**
* 倉庫類Storage實現緩衝區
*
* Email:[email protected]
*
* @author MONKEY.D.MENG 2011-03-15
*
*/
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;
}
}
/**
* 生產者類Producer繼承線程類Thread
*
* Email:[email protected]
*
* @author MONKEY.D.MENG 2011-03-15
*
*/
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;
}
}
/**
* 消費者類Consumer繼承線程類Thread
*
* Email:[email protected]
*
* @author MONKEY.D.MENG 2011-03-15
*
*/
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;
}
}
/**
* 測試類Test
*
* Email:[email protected]
*
* @author MONKEY.D.MENG 2011-03-15
*
*/
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();
}
}
【要消費的產品數量】:50 【庫存量】:0 暫時不能執行生產任務!
【要消費的產品數量】:30 【庫存量】:0 暫時不能執行生產任務!
【要消費的產品數量】:20 【庫存量】:0 暫時不能執行生產任務!
【已經生產產品數】:10 【現倉儲量為】:10
【要消費的產品數量】:20 【庫存量】:10 暫時不能執行生產任務!
【要消費的產品數量】:30 【庫存量】:10 暫時不能執行生產任務!
【要消費的產品數量】:50 【庫存量】:10 暫時不能執行生產任務!
【已經生產產品數】:10 【現倉儲量為】:20
【要消費的產品數量】:50 【庫存量】:20 暫時不能執行生產任務!
【要消費的產品數量】:30 【庫存量】:20 暫時不能執行生產任務!
【已經消費產品數】:20 【現倉儲量為】:0
【已經生產產品數】:10 【現倉儲量為】:10
【已經生產產品數】:10 【現倉儲量為】:20
【已經生產產品數】:80 【現倉儲量為】:100
【要生產的產品數量】:10 【庫存量】:100 暫時不能執行生產任務!
【已經消費產品數】:30 【現倉儲量為】:70
【已經消費產品數】:50 【現倉儲量為】:20
【已經生產產品數】:10 【現倉儲量為】:30
【已經生產產品數】:10 【現倉儲量為】:40看完上述代碼，對wait() / notify()方法實現的同步有了瞭解。你可能會對Storage類中為什麼要定義public void produce(int num);和public void consume(int num);方法感到不解，為什麼不直接在生產者類Producer和消費者類Consumer中實現這兩個方法，卻要調用Storage類中的實現呢？淡定，後文會有解釋。我們先往下走。
練習一個小例子
使用多線程進行交替輸出奇數偶數。t1輸出奇數，t2輸出偶數。
package com.example;
public class ProducerAndCustomer {
/*
使用多線程進行交替輸出奇數偶數。t1輸出奇數，t2輸出偶數。
*/
public static void main(String[] args) {
Num num = new Num();
Thread t1 = new Thread(new Producterb(num));
Thread t2 = new Thread(new Customer(num));
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
}
class Num{
int i = 1;
}
class Producterb implements Runnable{
private Num num;
public Producterb(Num num) {
this.num = num;
}
@Override
public void run() {
while(true){
synchronized (num) {
if (num.i % 2 == 0) {
try {
Thread.sleep(1000);//休眠一秒可以跟好的看見執行效果
num.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//程式可以走到這裡說明num是奇數
System.out.println(Thread.currentThread().getName()+"--->"+num.i++);
num.notifyAll();
}
}
}
}
class Customer implements Runnable{
private Num num;
public Customer(Num num) {
this.num = num;
}
@Override
public void run() {
while(true){
synchronized (num) {
if (num.i % 2 == 1) {
try {
Thread.sleep(1000);
num.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//程式執行到此說明num是奇數
System.out.println(Thread.currentThread().getName()+"--->"+num.i++);
num.notifyAll();
}
}
}
}
二、await() / signal()方法
在JDK5.0之後，Java提供了更加健壯的線程處理機制，包括同步、鎖定、線程池等，它們可以實現更細粒度的線程式控制制。await()和signal()就是其中用來做同步的兩種方法，它們的功能基本上和wait() / nofity()相同，完全可以取代它們，但是它們和新引入的鎖定機制Lock直接掛鉤，具有更大的靈活性。通過在Lock對象上調用newCondition()方法，將條件變數和一個鎖對象進行綁定，進而控制併發程式訪問競爭資源的安全。下麵來看代碼：
import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 倉庫類Storage實現緩衝區
*
* Email:[email protected]
*
* @author MONKEY.D.MENG 2011-03-15
*
*/
public class Storage
{
// 倉庫最大存儲量
private final int MAX_SIZE = 100;
// 倉庫存儲的載體
private LinkedList<Object> list = new LinkedList<Object>();
// 鎖
private final Lock lock = new ReentrantLock();
// 倉庫滿的條件變數
private final Condition full = lock.newCondition();
// 倉庫空的條件變數
private final Condition empty = lock.newCondition();
// 生產num個產品
public void produce(int num)
{
// 獲得鎖
lock.lock();
// 如果倉庫剩餘容量不足
while (list.size() + num > MAX_SIZE)
{
System.out.println("【要生產的產品數量】:" + num + "/t【庫存量】:" + list.size()
+ "/t暫時不能執行生產任務!");
try
{
// 由於條件不滿足，生產阻塞
full.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
// 生產條件滿足情況下，生產num個產品
for (int i = 1; i <= num; ++i)
{
list.add(new Object());
}
System.out.println("【已經生產產品數】:" + num + "/t【現倉儲量為】:" + list.size());
// 喚醒其他所有線程
full.signalAll();
empty.signalAll();
// 釋放鎖
lock.unlock();
}
// 消費num個產品
public void consume(int num)
{
// 獲得鎖
lock.lock();
// 如果倉庫存儲量不足
while (list.size() < num)
{
System.out.println("【要消費的產品數量】:" + num + "/t【庫存量】:" + list.size()
+ "/t暫時不能執行生產任務!");
try
{
// 由於條件不滿足，消費阻塞
empty.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
// 消費條件滿足情況下，消費num個產品
for (int i = 1; i <= num; ++i)
{
list.remove();
}
System.out.println("【已經消費產品數】:" + num + "/t【現倉儲量為】:" + list.size());
// 喚醒其他所有線程
full.signalAll();
empty.signalAll();
// 釋放鎖
lock.unlock();
}
// set/get方法
public int getMAX_SIZE()
{
return MAX_SIZE;
}
public LinkedList<Object> getList()
{
return list;
}
public void setList(LinkedList<Object> list)
{
this.list = list;
}
}
【要消費的產品數量】:50 【庫存量】:0 暫時不能執行生產任務!
【要消費的產品數量】:30 【庫存量】:0 暫時不能執行生產任務!
【已經生產產品數】:10 【現倉儲量為】:10
【已經生產產品數】:10 【現倉儲量為】:20
【要消費的產品數量】:50 【庫存量】:20 暫時不能執行生產任務!
【要消費的產品數量】:30 【庫存量】:20 暫時不能執行生產任務!
【已經生產產品數】:10 【現倉儲量為】:30
【要消費的產品數量】:50 【庫存量】:30 暫時不能執行生產任務!
【已經消費產品數】:20 【現倉儲量為】:10
【已經生產產品數】:10 【現倉儲量為】:20
【要消費的產品數量】:30 【庫存量】:20 暫時不能執行生產任務!
【已經生產產品數】:80 【現倉儲量為】:100
【要生產的產品數量】:10 【庫存量】:100 暫時不能執行生產任務!
【已經消費產品數】:50 【現倉儲量為】:50
【已經生產產品數】:10 【現倉儲量為】:60
【已經消費產品數】:30 【現倉儲量為】:30
【已經生產產品數】:10 【現倉儲量為】:40
三、BlockingQueue阻塞隊列方法
BlockingQueue是JDK5.0的新增內容，它是一個已經在內部實現了同步的隊列，實現方式採用的是我們第2種await() / signal()方法。它可以在生成對象時指定容量大小。它用於阻塞操作的是put()和take()方法。
put()方法：類似於我們上面的生產者線程，容量達到最大時，自動阻塞。
take()方法：類似於我們上面的消費者線程，容量為0時，自動阻塞。
關於BlockingQueue的內容網上有很多，大家可以自己搜，我在這不多介紹。下麵直接看代碼，跟以往一樣，我們只需要更改倉庫類Storage的代碼即可：
import java.util.concurrent.LinkedBlockingQueue;
/**
* 倉庫類Storage實現緩衝區
*
*/
public class Storage
{
// 倉庫最大存儲量
private final int MAX_SIZE = 100;
// 倉庫存儲的載體
private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<Object>(
100);
// 生產num個產品
public void produce(int num)
{
// 如果倉庫剩餘容量為0
if (list.size() == MAX_SIZE)
{
System.out.println("【庫存量】:" + MAX_SIZE + "/t暫時不能執行生產任務!");
}
// 生產條件滿足情況下，生產num個產品
for (int i = 1; i <= num; ++i)
{
try
{
// 放入產品，自動阻塞
list.put(new Object());
}
catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println("【現倉儲量為】:" + list.size());
}
}
// 消費num個產品
public void consume(int num)
{
// 如果倉庫存儲量不足
if (list.size() == 0)
{
System.out.println("【庫存量】:0/t暫時不能執行生產任務!");
}
// 消費條件滿足情況下，消費num個產品
for (int i = 1; i <= num; ++i)
{
try
{
// 消費產品，自動阻塞
list.take();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
System.out.println("【現倉儲量為】:" + list.size());
}
// set/get方法
public LinkedBlockingQueue<Object> getList()
{
return list;
}
public void setList(LinkedBlockingQueue<Object> list)
{
this.list = list;
}
public int getMAX_SIZE()
{
return MAX_SIZE;
}
}
【庫存量】:0 暫時不能執行生產任務!
【庫存量】:0 暫時不能執行生產任務!
【現倉儲量為】:1
【現倉儲量為】:1
【現倉儲量為】:3
【現倉儲量為】:4
【現倉儲量為】:5
【現倉儲量為】:6
【現倉儲量為】:7
【現倉儲量為】:8
【現倉儲量為】:9
【現倉儲量為】:10
【現倉儲量為】:11
【現倉儲量為】:1
【現倉儲量為】:2
【現倉儲量為】:13
【現倉儲量為】:14
【現倉儲量為】:17
【現倉儲量為】:19
【現倉儲量為】:20
【現倉儲量為】:21
【現倉儲量為】:22
【現倉儲量為】:23
【現倉儲量為】:24
【現倉儲量為】:25
【現倉儲量為】:26
【現倉儲量為】:12
【現倉儲量為】:1
【現倉儲量為】:1
【現倉儲量為】:2
【現倉儲量為】:3
【現倉儲量為】:4
【現倉儲量為】:5
【現倉儲量為】:6
【現倉儲量為】:7
【現倉儲量為】:27
【現倉儲量為】:8
【現倉儲量為】:6
【現倉儲量為】:18
【現倉儲量為】:2
【現倉儲量為】:3
【現倉儲量為】:4
【現倉儲量為】:5
【現倉儲量為】:6
【現倉儲量為】:7
【現倉儲量為】:8
【現倉儲量為】:9
【現倉儲量為】:10
【現倉儲量為】:16
【現倉儲量為】:11
【現倉儲量為】:12
【現倉儲量為】:13
【現倉儲量為】:14
【現倉儲量為】:15
【現倉儲量為】:1
【現倉儲量為】:2
【現倉儲量為】:3
【現倉儲量為】:3
【現倉儲量為】:15
【現倉儲量為】:1
【現倉儲量為】:0
【現倉儲量為】:1
【現倉儲量為】:1
【現倉儲量為】:1
【現倉儲量為】:2
【現倉儲量為】:3
【現倉儲量為】:4
【現倉儲量為】:0
【現倉儲量為】:1
【現倉儲量為】:5
【現倉儲量為】:6
【現倉儲量為】:7
【現倉儲量為】:8
【現倉儲量為】:9
【現倉儲量為】:10
【現倉儲量為】:11
【現倉儲量為】:12
【現倉儲量為】:13
【現倉儲量為】:14
【現倉儲量為】:15
【現倉儲量為】:16
【現倉儲量為】:17
【現倉儲量為】:1
【現倉儲量為】:1
【現倉儲量為】:2
【現倉儲量為】:3
【現倉儲量為】:4
【現倉儲量為】:5
【現倉儲量為】:6
【現倉儲量為】:3
【現倉儲量為】:3
【現倉儲量為】:1
【現倉儲量為】:2
【現倉儲量為】:3
【現倉儲量為】:4
【現倉儲量為】:5
【現倉儲量為】:6
【現倉儲量為】:7
【現倉儲量為】:8
【現倉儲量為】:9
【現倉儲量為】:10
【現倉儲量為】:11
【現倉儲量為】:12
【現倉儲量為】:13
【現倉儲量為】:14
【現倉儲量為】:15
【現倉儲量為】:16
【現倉儲量為】:17
【現倉儲量為】:18
【現倉儲量為】:19
【現倉儲量為】:6
【現倉儲量為】:7
【現倉儲量為】:8
【現倉儲量為】:9
【現倉儲量為】:10
【現倉儲量為】:11
【現倉儲量為】:12
【現倉儲量為】:13
【現倉儲量為】:14
【現倉儲量為】:15
【現倉儲量為】:16
【現倉儲量為】:17
【現倉儲量為】:18
【現倉儲量為】:19
【現倉儲量為】:20
【現倉儲量為】:21
【現倉儲量為】:22
【現倉儲量為】:23
【現倉儲量為】:24
【現倉儲量為】:25
【現倉儲量為】:26
【現倉儲量為】:27
【現倉儲量為】:28
【現倉儲量為】:29
【現倉儲量為】:30
【現倉儲量為】:31
【現倉儲量為】:32
【現倉儲量為】:33
【現倉儲量為】:34
【現倉儲量為】:35
【現倉儲量為】:36
【現倉儲量為】:37
【現倉儲量為】:38
【現倉儲量為】:39
【現倉儲量為】:40當然，你會發現這時對於public void produce(int num);和public void consume(int num);方法業務邏輯上的實現跟前面兩個例子不太一樣，沒關係，這個例子只是為了說明BlockingQueue阻塞隊列的使用。
對於BlockingQueue大家可以放心使用，這可不是它的問題，只是在它和別的對象之間的同步有問題。
