生產者/消費者

原創 TimzzZ 2018-09-02 07:47

生產者/消費者問題的多種Java實現方式

 

轉載自：http://blog.csdn.net/monkey_d_meng/article/details/6251879

實質上，很多後臺服務程序併發控制的基本原理都可以歸納爲生產者/消費者模式，而這是恰恰是在本科操作系統課堂上老師反覆講解，而我們卻視而不見不以爲然的。在博文《一種面向作業流(工作流)的輕量級可複用的異步流水開發框架的設計與實現》中將介紹一種生產者/消費者模式的具體應用。

生產者消費者問題是研究多線程程序時繞不開的經典問題之一，它描述是有一塊緩衝區作爲倉庫，生產者可以將產品放入倉庫，消費者則可以從倉庫中取走產品。解決生產者/消費者問題的方法可分爲兩類：（1）採用某種機制保護生產者和消費者之間的同步；（2）在生產者和消費者之間建立一個管道。第一種方式有較高的效率，並且易於實現，代碼的可控制性較好，屬於常用的模式。第二種管道緩衝區不易控制，被傳輸數據對象不易於封裝等，實用性不強。因此本文只介紹同步機制實現的生產者/消費者問題。

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

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

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

（3）BlockingQueue阻塞隊列方法

（4）PipedInputStream / PipedOutputStream

本文只介紹最常用的前三種，第四種暫不做討論，有興趣的讀者可以自己去網上找答案。

 

一、wait() / notify()方法

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

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

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

光看文字可能不太好理解，咱來段代碼就明白了：

[java] view plain copy
print?
  1. import java.util.LinkedList;  
  2.   
  3. /** 
  4.  * 倉庫類Storage實現緩衝區 
  5.  *  
  6.  * Email:[email protected] 
  7.  *  
  8.  * @author MONKEY.D.MENG 2011-03-15 
  9.  *  
  10.  */  
  11. public class Storage  
  12. {  
  13.     // 倉庫最大存儲量  
  14.     private final int MAX_SIZE = 100;  
  15.   
  16.     // 倉庫存儲的載體  
  17.     private LinkedList<Object> list = new LinkedList<Object>();  
  18.   
  19.     // 生產num個產品  
  20.     public void produce(int num)  
  21.     {  
  22.         // 同步代碼段  
  23.         synchronized (list)  
  24.         {  
  25.             // 如果倉庫剩餘容量不足  
  26.             while (list.size() + num > MAX_SIZE)  
  27.             {  
  28.                 System.out.println(”【要生產的產品數量】:” + num + “/t【庫存量】:”  
  29.                         + list.size() + ”/t暫時不能執行生產任務!”);  
  30.                 try  
  31.                 {  
  32.                     // 由於條件不滿足，生產阻塞  
  33.                     list.wait();  
  34.                 }  
  35.                 catch (InterruptedException e)  
  36.                 {  
  37.                     e.printStackTrace();  
  38.                 }  
  39.             }  
  40.   
  41.             // 生產條件滿足情況下，生產num個產品  
  42.             for (int i = 1; i <= num; ++i)  
  43.             {  
  44.                 list.add(new Object());  
  45.             }  
  46.   
  47.             System.out.println(”【已經生產產品數】:” + num + “/t【現倉儲量爲】:” + list.size());  
  48.   
  49.             list.notifyAll();  
  50.         }  
  51.     }  
  52.   
  53.     // 消費num個產品  
  54.     public void consume(int num)  
  55.     {  
  56.         // 同步代碼段  
  57.         synchronized (list)  
  58.         {  
  59.             // 如果倉庫存儲量不足  
  60.             while (list.size() < num)  
  61.             {  
  62.                 System.out.println(”【要消費的產品數量】:” + num + “/t【庫存量】:”  
  63.                         + list.size() + ”/t暫時不能執行生產任務!”);  
  64.                 try  
  65.                 {  
  66.                     // 由於條件不滿足，消費阻塞  
  67.                     list.wait();  
  68.                 }  
  69.                 catch (InterruptedException e)  
  70.                 {  
  71.                     e.printStackTrace();  
  72.                 }  
  73.             }  
  74.   
  75.             // 消費條件滿足情況下，消費num個產品  
  76.             for (int i = 1; i <= num; ++i)  
  77.             {  
  78.                 list.remove();  
  79.             }  
  80.   
  81.             System.out.println(”【已經消費產品數】:” + num + “/t【現倉儲量爲】:” + list.size());  
  82.   
  83.             list.notifyAll();  
  84.         }  
  85.     }  
  86.   
  87.     // get/set方法  
  88.     public LinkedList<Object> getList()  
  89.     {  
  90.         return list;  
  91.     }  
  92.   
  93.     public void setList(LinkedList<Object> list)  
  94.     {  
  95.         this.list = list;  
  96.     }  
  97.   
  98.     public int getMAX_SIZE()  
  99.     {  
  100.         return MAX_SIZE;  
  101.     }  
  102. }  
  103. /** 
  104.  * 生產者類Producer繼承線程類Thread 
  105.  *  
  106.  * Email:[email protected] 
  107.  *  
  108.  * @author MONKEY.D.MENG 2011-03-15 
  109.  *  
  110.  */  
  111. public class Producer extends Thread  
  112. {  
  113.     // 每次生產的產品數量  
  114.     private int num;  
  115.   
  116.     // 所在放置的倉庫  
  117.     private Storage storage;  
  118.   
  119.     // 構造函數，設置倉庫  
  120.     public Producer(Storage storage)  
  121.     {  
  122.         this.storage = storage;  
  123.     }  
  124.   
  125.     // 線程run函數  
  126.     public void run()  
  127.     {  
  128.         produce(num);  
  129.     }  
  130.   
  131.     // 調用倉庫Storage的生產函數  
  132.     public void produce(int num)  
  133.     {  
  134.         storage.produce(num);  
  135.     }  
  136.   
  137.     // get/set方法  
  138.     public int getNum()  
  139.     {  
  140.         return num;  
  141.     }  
  142.   
  143.     public void setNum(int num)  
  144.     {  
  145.         this.num = num;  
  146.     }  
  147.   
  148.     public Storage getStorage()  
  149.     {  
  150.         return storage;  
  151.     }  
  152.   
  153.     public void setStorage(Storage storage)  
  154.     {  
  155.         this.storage = storage;  
  156.     }  
  157. }  
  158. /** 
  159.  * 消費者類Consumer繼承線程類Thread 
  160.  *  
  161.  * Email:[email protected] 
  162.  *  
  163.  * @author MONKEY.D.MENG 2011-03-15 
  164.  *  
  165.  */  
  166. public class Consumer extends Thread  
  167. {  
  168.     // 每次消費的產品數量  
  169.     private int num;  
  170.   
  171.     // 所在放置的倉庫  
  172.     private Storage storage;  
  173.   
  174.     // 構造函數，設置倉庫  
  175.     public Consumer(Storage storage)  
  176.     {  
  177.         this.storage = storage;  
  178.     }  
  179.   
  180.     // 線程run函數  
  181.     public void run()  
  182.     {  
  183.         consume(num);  
  184.     }  
  185.   
  186.     // 調用倉庫Storage的生產函數  
  187.     public void consume(int num)  
  188.     {  
  189.         storage.consume(num);  
  190.     }  
  191.   
  192.     // get/set方法  
  193.     public int getNum()  
  194.     {  
  195.         return num;  
  196.     }  
  197.   
  198.     public void setNum(int num)  
  199.     {  
  200.         this.num = num;  
  201.     }  
  202.   
  203.     public Storage getStorage()  
  204.     {  
  205.         return storage;  
  206.     }  
  207.   
  208.     public void setStorage(Storage storage)  
  209.     {  
  210.         this.storage = storage;  
  211.     }  
  212. }  
  213. /** 
  214.  * 測試類Test 
  215.  *  
  216.  * Email:[email protected] 
  217.  *  
  218.  * @author MONKEY.D.MENG 2011-03-15 
  219.  *  
  220.  */  
  221. public class Test  
  222. {  
  223.     public static void main(String[] args)  
  224.     {  
  225.         // 倉庫對象  
  226.         Storage storage = new Storage();  
  227.   
  228.         // 生產者對象  
  229.         Producer p1 = new Producer(storage);  
  230.         Producer p2 = new Producer(storage);  
  231.         Producer p3 = new Producer(storage);  
  232.         Producer p4 = new Producer(storage);  
  233.         Producer p5 = new Producer(storage);  
  234.         Producer p6 = new Producer(storage);  
  235.         Producer p7 = new Producer(storage);  
  236.   
  237.         // 消費者對象  
  238.         Consumer c1 = new Consumer(storage);  
  239.         Consumer c2 = new Consumer(storage);  
  240.         Consumer c3 = new Consumer(storage);  
  241.   
  242.         // 設置生產者產品生產數量  
  243.         p1.setNum(10);  
  244.         p2.setNum(10);  
  245.         p3.setNum(10);  
  246.         p4.setNum(10);  
  247.         p5.setNum(10);  
  248.         p6.setNum(10);  
  249.         p7.setNum(80);  
  250.   
  251.         // 設置消費者產品消費數量  
  252.         c1.setNum(50);  
  253.         c2.setNum(20);  
  254.         c3.setNum(30);  
  255.   
  256.         // 線程開始執行  
  257.         c1.start();  
  258.         c2.start();  
  259.         c3.start();  
  260.         p1.start();  
  261.         p2.start();  
  262.         p3.start();  
  263.         p4.start();  
  264.         p5.start();  
  265.         p6.start();  
  266.         p7.start();  
  267.     }  
  268. }  
  269. 【要消費的產品數量】:50   【庫存量】:0 暫時不能執行生產任務!  
  270. 【要消費的產品數量】:30   【庫存量】:0 暫時不能執行生產任務!  
  271. 【要消費的產品數量】:20   【庫存量】:0 暫時不能執行生產任務!  
  272. 【已經生產產品數】:10    【現倉儲量爲】:10  
  273. 【要消費的產品數量】:20   【庫存量】:10    暫時不能執行生產任務!  
  274. 【要消費的產品數量】:30   【庫存量】:10    暫時不能執行生產任務!  
  275. 【要消費的產品數量】:50   【庫存量】:10    暫時不能執行生產任務!  
  276. 【已經生產產品數】:10    【現倉儲量爲】:20  
  277. 【要消費的產品數量】:50   【庫存量】:20    暫時不能執行生產任務!  
  278. 【要消費的產品數量】:30   【庫存量】:20    暫時不能執行生產任務!  
  279. 【已經消費產品數】:20    【現倉儲量爲】:0  
  280. 【已經生產產品數】:10    【現倉儲量爲】:10  
  281. 【已經生產產品數】:10    【現倉儲量爲】:20  
  282. 【已經生產產品數】:80    【現倉儲量爲】:100  
  283. 【要生產的產品數量】:10   【庫存量】:100   暫時不能執行生產任務!  
  284. 【已經消費產品數】:30    【現倉儲量爲】:70  
  285. 【已經消費產品數】:50    【現倉儲量爲】:20  
  286. 【已經生產產品數】:10    【現倉儲量爲】:30  
  287. 【已經生產產品數】:10    【現倉儲量爲】:40  

看完上述代碼，對wait() / notify()方法實現的同步有了瞭解。你可能會對Storage類中爲什麼要定義public void produce(int num);和public void consume(int num);方法感到不解，爲什麼不直接在生產者類Producer和消費者類Consumer中實現這兩個方法，卻要調用Storage類中的實現呢？淡定，後文會有解釋。我們先往下走。

 

二、await() / signal()方法

在JDK5.0之後，Java提供了更加健壯的線程處理機制，包括同步、鎖定、線程池等，它們可以實現更細粒度的線程控制。await()和signal()就是其中用來做同步的兩種方法，它們的功能基本上和wait() / nofity()相同，完全可以取代它們，但是它們和新引入的鎖定機制Lock直接掛鉤，具有更大的靈活性。通過在Lock對象上調用newCondition()方法，將條件變量和一個鎖對象進行綁定，進而控制併發程序訪問競爭資源的安全。下面來看代碼：

[java] view plain copy
print?
  1. import java.util.LinkedList;  
  2. import java.util.concurrent.locks.Condition;  
  3. import java.util.concurrent.locks.Lock;  
  4. import java.util.concurrent.locks.ReentrantLock;  
  5.   
  6. /** 
  7.  * 倉庫類Storage實現緩衝區 
  8.  *  
  9.  * Email:[email protected] 
  10.  *  
  11.  * @author MONKEY.D.MENG 2011-03-15 
  12.  *  
  13.  */  
  14. public class Storage  
  15. {  
  16.     // 倉庫最大存儲量  
  17.     private final int MAX_SIZE = 100;  
  18.   
  19.     // 倉庫存儲的載體  
  20.     private LinkedList<Object> list = new LinkedList<Object>();  
  21.   
  22.     // 鎖  
  23.     private final Lock lock = new ReentrantLock();  
  24.   
  25.     // 倉庫滿的條件變量  
  26.     private final Condition full = lock.newCondition();  
  27.   
  28.     // 倉庫空的條件變量  
  29.     private final Condition empty = lock.newCondition();  
  30.   
  31.     // 生產num個產品  
  32.     public void produce(int num)  
  33.     {  
  34.         // 獲得鎖  
  35.         lock.lock();  
  36.   
  37.         // 如果倉庫剩餘容量不足  
  38.         while (list.size() + num > MAX_SIZE)  
  39.         {  
  40.             System.out.println(”【要生產的產品數量】:” + num + “/t【庫存量】:” + list.size()  
  41.                     + ”/t暫時不能執行生產任務!”);  
  42.             try  
  43.             {  
  44.                 // 由於條件不滿足，生產阻塞  
  45.                 full.await();  
  46.             }  
  47.             catch (InterruptedException e)  
  48.             {  
  49.                 e.printStackTrace();  
  50.             }  
  51.         }  
  52.   
  53.         // 生產條件滿足情況下，生產num個產品  
  54.         for (int i = 1; i <= num; ++i)  
  55.         {  
  56.             list.add(new Object());  
  57.         }  
  58.   
  59.         System.out.println(”【已經生產產品數】:” + num + “/t【現倉儲量爲】:” + list.size());  
  60.   
  61.         // 喚醒其他所有線程  
  62.         full.signalAll();  
  63.         empty.signalAll();  
  64.   
  65.         // 釋放鎖  
  66.         lock.unlock();  
  67.     }  
  68.   
  69.     // 消費num個產品  
  70.     public void consume(int num)  
  71.     {  
  72.         // 獲得鎖  
  73.         lock.lock();  
  74.   
  75.         // 如果倉庫存儲量不足  
  76.         while (list.size() < num)  
  77.         {  
  78.             System.out.println(”【要消費的產品數量】:” + num + “/t【庫存量】:” + list.size()  
  79.                     + ”/t暫時不能執行生產任務!”);  
  80.             try  
  81.             {  
  82.                 // 由於條件不滿足，消費阻塞  
  83.                 empty.await();  
  84.             }  
  85.             catch (InterruptedException e)  
  86.             {  
  87.                 e.printStackTrace();  
  88.             }  
  89.         }  
  90.   
  91.         // 消費條件滿足情況下，消費num個產品  
  92.         for (int i = 1; i <= num; ++i)  
  93.         {  
  94.             list.remove();  
  95.         }  
  96.   
  97.         System.out.println(”【已經消費產品數】:” + num + “/t【現倉儲量爲】:” + list.size());  
  98.   
  99.         // 喚醒其他所有線程  
  100.         full.signalAll();  
  101.         empty.signalAll();  
  102.   
  103.         // 釋放鎖  
  104.         lock.unlock();  
  105.     }  
  106.   
  107.     // set/get方法  
  108.     public int getMAX_SIZE()  
  109.     {  
  110.         return MAX_SIZE;  
  111.     }  
  112.   
  113.     public LinkedList<Object> getList()  
  114.     {  
  115.         return list;  
  116.     }  
  117.   
  118.     public void setList(LinkedList<Object> list)  
  119.     {  
  120.         this.list = list;  
  121.     }  
  122. }  
  123. 【要消費的產品數量】:50   【庫存量】:0 暫時不能執行生產任務!  
  124. 【要消費的產品數量】:30   【庫存量】:0 暫時不能執行生產任務!  
  125. 【已經生產產品數】:10    【現倉儲量爲】:10  
  126. 【已經生產產品數】:10    【現倉儲量爲】:20  
  127. 【要消費的產品數量】:50   【庫存量】:20    暫時不能執行生產任務!  
  128. 【要消費的產品數量】:30   【庫存量】:20    暫時不能執行生產任務!  
  129. 【已經生產產品數】:10    【現倉儲量爲】:30  
  130. 【要消費的產品數量】:50   【庫存量】:30    暫時不能執行生產任務!  
  131. 【已經消費產品數】:20    【現倉儲量爲】:10  
  132. 【已經生產產品數】:10    【現倉儲量爲】:20  
  133. 【要消費的產品數量】:30   【庫存量】:20    暫時不能執行生產任務!  
  134. 【已經生產產品數】:80    【現倉儲量爲】:100  
  135. 【要生產的產品數量】:10   【庫存量】:100   暫時不能執行生產任務!  
  136. 【已經消費產品數】:50    【現倉儲量爲】:50  
  137. 【已經生產產品數】:10    【現倉儲量爲】:60  
  138. 【已經消費產品數】:30    【現倉儲量爲】:30  
  139. 【已經生產產品數】:10    【現倉儲量爲】:40  

 

只需要更新倉庫類Storage的代碼即可，生產者Producer、消費者Consumer、測試類Test的代碼均不需要進行任何更改。這樣我們就知道爲神馬我要在Storage類中定義public void produce(int num);和public void consume(int num);方法，並在生產者類Producer和消費者類Consumer中調用Storage類中的實現了吧。將可能發生的變化集中到一個類中，不影響原有的構架設計，同時無需修改其他業務層代碼。無意之中，我們好像使用了某種設計模式，具體是啥我忘記了，啊哈哈，等我想起來再告訴大家~

 

三、BlockingQueue阻塞隊列方法

BlockingQueue是JDK5.0的新增內容，它是一個已經在內部實現了同步的隊列，實現方式採用的是我們第2種await() / signal()方法。它可以在生成對象時指定容量大小。它用於阻塞操作的是put()和take()方法。

put()方法：類似於我們上面的生產者線程，容量達到最大時，自動阻塞。

take()方法：類似於我們上面的消費者線程，容量爲0時，自動阻塞。

關於BlockingQueue的內容網上有很多，大家可以自己搜，我在這不多介紹。下面直接看代碼，跟以往一樣，我們只需要更改倉庫類Storage的代碼即可：

[java] view plain copy
print?
  1. import java.util.concurrent.LinkedBlockingQueue;  
  2.   
  3. /** 
  4.  * 倉庫類Storage實現緩衝區 
  5.  *  
  6.  * Email:[email protected] 
  7.  *  
  8.  * @author MONKEY.D.MENG 2011-03-15 
  9.  *  
  10.  */  
  11. public class Storage  
  12. {  
  13.     // 倉庫最大存儲量  
  14.     private final int MAX_SIZE = 100;  
  15.   
  16.     // 倉庫存儲的載體  
  17.     private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<Object>(  
  18.             100);  
  19.   
  20.     // 生產num個產品  
  21.     public void produce(int num)  
  22.     {  
  23.         // 如果倉庫剩餘容量爲0  
  24.         if (list.size() == MAX_SIZE)  
  25.         {  
  26.             System.out.println(”【庫存量】:” + MAX_SIZE + “/t暫時不能執行生產任務!”);  
  27.         }  
  28.   
  29.         // 生產條件滿足情況下，生產num個產品  
  30.         for (int i = 1; i <= num; ++i)  
  31.         {  
  32.             try  
  33.             {  
  34.                 // 放入產品，自動阻塞  
  35.                 list.put(new Object());  
  36.             }  
  37.             catch (InterruptedException e)  
  38.             {  
  39.                 e.printStackTrace();  
  40.             }  
  41.   
  42.             System.out.println(”【現倉儲量爲】:” + list.size());  
  43.         }  
  44.     }  
  45.   
  46.     // 消費num個產品  
  47.     public void consume(int num)  
  48.     {  
  49.         // 如果倉庫存儲量不足  
  50.         if (list.size() == 0)  
  51.         {  
  52.             System.out.println(”【庫存量】:0/t暫時不能執行生產任務!”);  
  53.         }  
  54.   
  55.         // 消費條件滿足情況下，消費num個產品  
  56.         for (int i = 1; i <= num; ++i)  
  57.         {  
  58.             try  
  59.             {  
  60.                 // 消費產品，自動阻塞  
  61.                 list.take();  
  62.             }  
  63.             catch (InterruptedException e)  
  64.             {  
  65.                 e.printStackTrace();  
  66.             }  
  67.         }  
  68.   
  69.         System.out.println(”【現倉儲量爲】:” + list.size());  
  70.     }  
  71.   
  72.     // set/get方法  
  73.     public LinkedBlockingQueue<Object> getList()  
  74.     {  
  75.         return list;  
  76.     }  
  77.   
  78.     public void setList(LinkedBlockingQueue<Object> list)  
  79.     {  
  80.         this.list = list;  
  81.     }  
  82.   
  83.     public int getMAX_SIZE()  
  84.     {  
  85.         return MAX_SIZE;  
  86.     }  
  87. }  
  88. 【庫存量】:0 暫時不能執行生產任務!  
  89. 【庫存量】:0 暫時不能執行生產任務!  
  90. 【現倉儲量爲】:1  
  91. 【現倉儲量爲】:1  
  92. 【現倉儲量爲】:3  
  93. 【現倉儲量爲】:4  
  94. 【現倉儲量爲】:5  
  95. 【現倉儲量爲】:6  
  96. 【現倉儲量爲】:7  
  97. 【現倉儲量爲】:8  
  98. 【現倉儲量爲】:9  
  99. 【現倉儲量爲】:10  
  100. 【現倉儲量爲】:11  
  101. 【現倉儲量爲】:1  
  102. 【現倉儲量爲】:2  
  103. 【現倉儲量爲】:13  
  104. 【現倉儲量爲】:14  
  105. 【現倉儲量爲】:17  
  106. 【現倉儲量爲】:19  
  107. 【現倉儲量爲】:20  
  108. 【現倉儲量爲】:21  
  109. 【現倉儲量爲】:22  
  110. 【現倉儲量爲】:23  
  111. 【現倉儲量爲】:24  
  112. 【現倉儲量爲】:25  
  113. 【現倉儲量爲】:26  
  114. 【現倉儲量爲】:12  
  115. 【現倉儲量爲】:1  
  116. 【現倉儲量爲】:1  
  117. 【現倉儲量爲】:2  
  118. 【現倉儲量爲】:3  
  119. 【現倉儲量爲】:4  
  120. 【現倉儲量爲】:5  
  121. 【現倉儲量爲】:6  
  122. 【現倉儲量爲】:7  
  123. 【現倉儲量爲】:27  
  124. 【現倉儲量爲】:8  
  125. 【現倉儲量爲】:6  
  126. 【現倉儲量爲】:18  
  127. 【現倉儲量爲】:2  
  128. 【現倉儲量爲】:3  
  129. 【現倉儲量爲】:4  
  130. 【現倉儲量爲】:5  
  131. 【現倉儲量爲】:6  
  132. 【現倉儲量爲】:7  
  133. 【現倉儲量爲】:8  
  134. 【現倉儲量爲】:9  
  135. 【現倉儲量爲】:10  
  136. 【現倉儲量爲】:16  
  137. 【現倉儲量爲】:11  
  138. 【現倉儲量爲】:12  
  139. 【現倉儲量爲】:13  
  140. 【現倉儲量爲】:14  
  141. 【現倉儲量爲】:15  
  142. 【現倉儲量爲】:1  
  143. 【現倉儲量爲】:2  
  144. 【現倉儲量爲】:3  
  145. 【現倉儲量爲】:3  
  146. 【現倉儲量爲】:15  
  147. 【現倉儲量爲】:1  
  148. 【現倉儲量爲】:0  
  149. 【現倉儲量爲】:1  
  150. 【現倉儲量爲】:1  
  151. 【現倉儲量爲】:1  
  152. 【現倉儲量爲】:2  
  153. 【現倉儲量爲】:3  
  154. 【現倉儲量爲】:4  
  155. 【現倉儲量爲】:0  
  156. 【現倉儲量爲】:1  
  157. 【現倉儲量爲】:5  
  158. 【現倉儲量爲】:6  
  159. 【現倉儲量爲】:7  
  160. 【現倉儲量爲】:8  
  161. 【現倉儲量爲】:9  
  162. 【現倉儲量爲】:10  
  163. 【現倉儲量爲】:11  
  164. 【現倉儲量爲】:12  
  165. 【現倉儲量爲】:13  
  166. 【現倉儲量爲】:14  
  167. 【現倉儲量爲】:15  
  168. 【現倉儲量爲】:16  
  169. 【現倉儲量爲】:17  
  170. 【現倉儲量爲】:1  
  171. 【現倉儲量爲】:1  
  172. 【現倉儲量爲】:2  
  173. 【現倉儲量爲】:3  
  174. 【現倉儲量爲】:4  
  175. 【現倉儲量爲】:5  
  176. 【現倉儲量爲】:6  
  177. 【現倉儲量爲】:3  
  178. 【現倉儲量爲】:3  
  179. 【現倉儲量爲】:1  
  180. 【現倉儲量爲】:2  
  181. 【現倉儲量爲】:3  
  182. 【現倉儲量爲】:4  
  183. 【現倉儲量爲】:5  
  184. 【現倉儲量爲】:6  
  185. 【現倉儲量爲】:7  
  186. 【現倉儲量爲】:8  
  187. 【現倉儲量爲】:9  
  188. 【現倉儲量爲】:10  
  189. 【現倉儲量爲】:11  
  190. 【現倉儲量爲】:12  
  191. 【現倉儲量爲】:13  
  192. 【現倉儲量爲】:14  
  193. 【現倉儲量爲】:15  
  194. 【現倉儲量爲】:16  
  195. 【現倉儲量爲】:17  
  196. 【現倉儲量爲】:18  
  197. 【現倉儲量爲】:19  
  198. 【現倉儲量爲】:6  
  199. 【現倉儲量爲】:7  
  200. 【現倉儲量爲】:8  
  201. 【現倉儲量爲】:9  
  202. 【現倉儲量爲】:10  
  203. 【現倉儲量爲】:11  
  204. 【現倉儲量爲】:12  
  205. 【現倉儲量爲】:13  
  206. 【現倉儲量爲】:14  
  207. 【現倉儲量爲】:15  
  208. 【現倉儲量爲】:16  
  209. 【現倉儲量爲】:17  
  210. 【現倉儲量爲】:18  
  211. 【現倉儲量爲】:19  
  212. 【現倉儲量爲】:20  
  213. 【現倉儲量爲】:21  
  214. 【現倉儲量爲】:22  
  215. 【現倉儲量爲】:23  
  216. 【現倉儲量爲】:24  
  217. 【現倉儲量爲】:25  
  218. 【現倉儲量爲】:26  
  219. 【現倉儲量爲】:27  
  220. 【現倉儲量爲】:28  
  221. 【現倉儲量爲】:29  
  222. 【現倉儲量爲】:30  
  223. 【現倉儲量爲】:31  
  224. 【現倉儲量爲】:32  
  225. 【現倉儲量爲】:33  
  226. 【現倉儲量爲】:34  
  227. 【現倉儲量爲】:35  
  228. 【現倉儲量爲】:36  
  229. 【現倉儲量爲】:37  
  230. 【現倉儲量爲】:38  
  231. 【現倉儲量爲】:39  
  232. 【現倉儲量爲】: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大家可以放心使用，這可不是它的問題，只是在它和別的對象之間的同步有問題。

對於Java實現生產者/消費者問題的方法先總結到這裏面吧，過幾天實現一下C++版本的，接下來要馬上着手於基於生產者/消費者模式的《異步工作流服務框架的設計與實現》，請持續關注本博客。

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

java線程併發庫

  ThreadLocal的使用，，，實際上相當於維護了一個Map，其中以鍵值對的形式，存儲了某一個數據被多個線程訪問所對應的值。當然這個數據只能有

xinyetonghua 2020-07-08 12:36:33

分佈式系統各個節點狀態如何同步？淺談一下

寫在前面：2020年面試必備的Java後端進階面試題總結了一份複習指南在Github上，內容詳細，圖文並茂，有需要學習的朋友可以Star一下！ GitHub地址：https://github.com/abel-max/Java-S

毛发旺盛的程序员 2020-07-08 12:27:30

ZooKeeper 一致性協議 ZAB 原理，瞭解一下

一致性協議有很多種，比如 Paxos，Raft，2PC，3PC等等，在這講一種協議，ZAB 協議，該協議應該是所有一致性協議中生產環境中應用最多的了。爲什麼？因爲它是爲 Zookeeper 設計的分佈式一致性協議！ 1. 什麼是

毛发旺盛的程序员 2020-07-08 12:27:20

Spring中Transactional 失效的解決方案，讓我們一起探討一下

寫在前面：2020年面試必備的Java後端進階面試題總結了一份複習指南在Github上，內容詳細，圖文並茂，有需要學習的朋友可以Star一下！ GitHub地址：https://github.com/abel-max/Java-S

毛发旺盛的程序员 2020-07-08 12:27:20

太狠了,Spring全家桶筆記,一站式通關全攻略,已入職某廠漲薪18K

Spring 早已成爲 Java 後端開發事實上的行業標準，無數的公司選擇 Spring 作爲基礎的開發框架，大部分Java 後端程序員在日常工作中也會接觸到 Spring ，因此，如何用好 Spring ，也就成爲 Java

毛发旺盛的程序员 2020-07-08 12:27:20

java中的NAN和INFINITY java中的NAN和INFINITY

    java中的NAN和INFINITY   java浮點數運算中有兩個特殊的情況：NAN、INFINITY。 1、INFINITY： 在浮點數運算時，有時我們會遇到除數爲0的情況，那java是如何解決的呢？ 我們知道，在整型運算中

a318013800 2021-11-28 13:09:28

【Java 小白菜入門筆記 2.2】常用的類和方法

Array Array 含有sort、fill、equals、BinarySearch等方法 import java.util.Arrays; import java.util.Random; public class Arra

江户川柯壮 2020-07-08 12:39:29

springboot增量打包更新--靜態資源分離打包

springboot部署打包爲jar，一般都是全量打包，jar包的大小通常都是超過100M的，並且在進行一般的頁面html微調、js修改、img替換、css樣式修改時也需要重新打包進行部署；每次微小的調整都需要重新打包就太煩了，一

CNOYG 2020-07-08 12:39:29

增加FastDfs多文件存儲路徑

項目需要增加聊天會話功能，涉及到上傳語音圖片等信息。考慮新增一個目錄，所有相關文件存在一個相同的目錄中。因此需要對原項目增加一個存儲的路徑。以前的項目因爲只有一個路徑，且已經運行中。走了些彎路，僅此記錄操作過程。nginx version

pengdayong77 2020-07-08 12:37:23

JSONArray指定日期的反序列化

 JSONArray序列化日期最初用到， 這個是全局設置，會有風險。     String[] dateFormats = new String[] {"yyyyMMdd"};                 JSONUtils.getM

pengdayong77 2020-07-08 12:37:23

java緩存對象，使之不需要每次都從數據庫中獲取,以提高程序性能

直接上源碼，定義一個抽象類，必須實現get方法。該方法是用來獲取需要緩存的對象的。  import java.util.HashMap; import java.util.Map; /** * 用於從數據庫中獲取相應值的緩存類 *

pengdayong77 2020-07-08 12:37:23

類加載和類實例化

Java程序中對類的使用方式分爲兩類 ：主動使用和被動使用 主動使用： 創建類的實例 訪問某個類或接口的靜態變量，或者對該靜態變量賦值 調用類的靜態方法 反射 初始化一個類的子類 java虛擬機啓動時被標明爲啓動類的類 從JDK

吃酒忘情殇 2020-07-08 12:36:21

大數據入門（七）win10上eclipse使用Hadoop的配置

目錄工具eclipse的Hadoop環境配置參考 系列： 大數據入門（一）環境搭建，VMware15+CentOS8.1 配置 https://blog.csdn.net/qq_34391511/article/details/1

33 Audrey 2020-07-08 12:35:23

Java動態綁定機制經典案列理解

如題，直接帶入案例進行理解Java的動態綁定機制，不多說直接上代碼了。 package one; public class JavaTest { public static void main(String[] args

柘月十七 2020-07-08 12:33:16

阿里年薪破百架構師推薦：鳥哥的Linux私房菜，搭配面試題，真香

在Linux實操的過程中，你是否有過這些疑問： 如何提取日誌中含有關鍵字的指定行，上一行或上幾行？ ln 做了符號鏈接，對符號鏈接進行權限修改，原文件是否會受到影響？ Shell 腳本里有很多特殊符號，到底該怎麼用？網上流傳的

毛发旺盛的程序员 2020-07-08 12:27:30