生產者消費者問題
簡介
生產者消費者模式并不是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可能會出現put()和System.out.println()輸出不匹配的情況，這是由于它們之間沒有同步造成的，當緩沖區已滿，生產者在put()操作時，put()內部呼叫了await()方法，放棄了執行緒的執行，然后消費者執行緒執行，呼叫take()方法，take()內部呼叫了signal()方法，通知生產者執行緒可以執行，致使在消費者的println()還沒運行的情況下生產者的println()先被執行，所以有了輸出不匹配的情況，
對于BlockingQueue大家可以放心使用，這可不是它的問題，只是在它和別的物件之間的同步有問題，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/547999.html
標籤：Java