2. 程式人生 > >生產者/消費者問題的多種Java實現方式

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

阿新 • • 發佈：2017-11-13
放棄 所有 rod 暫時 其他 err 來看 empty cer

實質上，很多後臺服務程序並發控制的基本原理都可以歸納為生產者/消費者模式，

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

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

（2）在生產者和消費者之間建立一個管道。第一種方式有較高的效率，並且易於實現，代碼的可控制性較好，屬於常用的模式。第二種管道緩沖區不易控制，被傳輸數據對象不易於封裝等，實用性不強。因此本文只介紹同步機制實現的生產者/消費者問題。

同步問題核心在於：如何保證同一資源被多個線程並發訪問時的完整性。常用的同步方法是采用信號或加鎖機制，保證資源在任意時刻至多被一個線程訪問。

Java語言在多線程編程上實現了完全對象化，提供了對同步機制的良好支持。在Java中一共有四種方法支持同步，其中前三個是同步方法，一個是管道方法。

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

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

（3）BlockingQueue阻塞隊列方法

（4）PipedInputStream / PipedOutputStream

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

一、wait() / notify()方法

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

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

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

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

  1. import java.util.LinkedList;
  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;
  16. // 倉庫存儲的載體
  17. private LinkedList<Object> list = new LinkedList<Object>();
  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. }
  41. // 生產條件滿足情況下，生產num個產品
  42. for (int i = 1; i <= num; ++i)
  43. {
  44. list.add(new Object());
  45. }
  47. System.out.println("【已經生產產品數】:" + num + "/t【現倉儲量為】:" + list.size());
  49. list.notifyAll();
  50. }
  51. }
  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. }
  75. // 消費條件滿足情況下，消費num個產品
  76. for (int i = 1; i <= num; ++i)
  77. {
  78. list.remove();
  79. }
  81. System.out.println("【已經消費產品數】:" + num + "/t【現倉儲量為】:" + list.size());
  83. list.notifyAll();
  84. }
  85. }
  87. // get/set方法
  88. public LinkedList<Object> getList()
  89. {
  90. return list;
  91. }
  93. public void setList(LinkedList<Object> list)
  94. {
  95. this.list = list;
  96. }
  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;
  116. // 所在放置的倉庫
  117. private Storage storage;
  119. // 構造函數，設置倉庫
  120. public Producer(Storage storage)
  121. {
  122. this.storage = storage;
  123. }
  125. // 線程run函數
  126. public void run()
  127. {
  128. produce(num);
  129. }
  131. // 調用倉庫Storage的生產函數
  132. public void produce(int num)
  133. {
  134. storage.produce(num);
  135. }
  137. // get/set方法
  138. public int getNum()
  139. {
  140. return num;
  141. }
  143. public void setNum(int num)
  144. {
  145. this.num = num;
  146. }
  148. public Storage getStorage()
  149. {
  150. return storage;
  151. }
  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;
  171. // 所在放置的倉庫
  172. private Storage storage;
  174. // 構造函數，設置倉庫
  175. public Consumer(Storage storage)
  176. {
  177. this.storage = storage;
  178. }
  180. // 線程run函數
  181. public void run()
  182. {
  183. consume(num);
  184. }
  186. // 調用倉庫Storage的生產函數
  187. public void consume(int num)
  188. {
  189. storage.consume(num);
  190. }
  192. // get/set方法
  193. public int getNum()
  194. {
  195. return num;
  196. }
  198. public void setNum(int num)
  199. {
  200. this.num = num;
  201. }
  203. public Storage getStorage()
  204. {
  205. return storage;
  206. }
  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();
  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);
  237. // 消費者對象
  238. Consumer c1 = new Consumer(storage);
  239. Consumer c2 = new Consumer(storage);
  240. Consumer c3 = new Consumer(storage);
  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);
  251. // 設置消費者產品消費數量
  252. c1.setNum(50);
  253. c2.setNum(20);
  254. c3.setNum(30);
  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()方法，將條件變量和一個鎖對象進行綁定，進而控制並發程序訪問競爭資源的安全。下面來看代碼：

  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;
  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;
  19. // 倉庫存儲的載體
  20. private LinkedList<Object> list = new LinkedList<Object>();
  22. // 鎖
  23. private final Lock lock = new ReentrantLock();
  25. // 倉庫滿的條件變量
  26. private final Condition full = lock.newCondition();
  28. // 倉庫空的條件變量
  29. private final Condition empty = lock.newCondition();
  31. // 生產num個產品
  32. public void produce(int num)
  33. {
  34. // 獲得鎖
  35. lock.lock();
  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. }
  53. // 生產條件滿足情況下，生產num個產品
  54. for (int i = 1; i <= num; ++i)
  55. {
  56. list.add(new Object());
  57. }
  59. System.out.println("【已經生產產品數】:" + num + "/t【現倉儲量為】:" + list.size());
  61. // 喚醒其他所有線程
  62. full.signalAll();
  63. empty.signalAll();
  65. // 釋放鎖
  66. lock.unlock();
  67. }
  69. // 消費num個產品
  70. public void consume(int num)
  71. {
  72. // 獲得鎖
  73. lock.lock();
  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. }
  91. // 消費條件滿足情況下，消費num個產品
  92. for (int i = 1; i <= num; ++i)
  93. {
  94. list.remove();
  95. }
  97. System.out.println("【已經消費產品數】:" + num + "/t【現倉儲量為】:" + list.size());
  99. // 喚醒其他所有線程
  100. full.signalAll();
  101. empty.signalAll();
  103. // 釋放鎖
  104. lock.unlock();
  105. }
  107. // set/get方法
  108. public int getMAX_SIZE()
  109. {
  110. return MAX_SIZE;
  111. }
  113. public LinkedList<Object> getList()
  114. {
  115. return list;
  116. }
  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的代碼即可：

  1. import java.util.concurrent.LinkedBlockingQueue;
  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;
  16. // 倉庫存儲的載體
  17. private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<Object>(
  18. 100);
  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. }
  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. }
  42. System.out.println("【現倉儲量為】:" + list.size());
  43. }
  44. }
  46. // 消費num個產品
  47. public void consume(int num)
  48. {
  49. // 如果倉庫存儲量不足
  50. if (list.size() == 0)
  51. {
  52. System.out.println("【庫存量】:0/t暫時不能執行生產任務!");
  53. }
  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. }
  69. System.out.println("【現倉儲量為】:" + list.size());
  70. }
  72. // set/get方法
  73. public LinkedBlockingQueue<Object> getList()
  74. {
  75. return list;
  76. }
  78. public void setList(LinkedBlockingQueue<Object> list)
  79. {
  80. this.list = list;
  81. }
  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實現方式

相關推薦

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

放棄 所有 rod 暫時 其他 err 來看 empty cer 實質上，很多後臺服務程序並發控制的基本原理都可以歸納為生產者/消費者模式， 生產者消費者問題是研究多線程程序時繞不開的經典問題之一，它描述是有一塊緩沖區作為倉庫，生產者可以將產品放入倉庫，消費者則可以從倉庫中

生產者/消費者問題java實現

一、題目描述        1）手寫生產者/消費者 二、解題思路        方案一）：利用執行緒實現生產者/消費者，結合wait和notify。 三、注意事項 &nb

生產者-消費者問題 java實現

import java.util.concurrent.Semaphore; /** * 訊號量(Semaphore)的使用。 <br> * 生產者和消費者的例子，庫存的管理。 */ public class ProducerAndConsumer { public static

生產者消費者模式-Java實現

感知階段 　　　　隨著軟體業的發展，網際網路使用者的日漸增多，併發這門藝術的興起似乎是那麼合情合理。每日PV十多億的淘寶，處理併發的手段可謂是業界一流。使用者訪問淘寶首頁的平均等待時間只有區區幾秒，但是伺服器所處理的流程十分複雜。首先負責首頁的伺服器就有好幾千臺，通過計算把

（十六）java併發程式設計--執行緒的死鎖解決方案(生產者和消費者幾種實現方式)

上一篇中,主要了解了什麼時候死鎖，並且提出死鎖的一個解決方案，多個鎖要按照一定的順序來。 本片主要是利用生產者消費者模式解決執行緒的死鎖。 多執行緒生產者和消費者一個典型的多執行緒程式。一個生產者生產提供消費的東西，但是生產速度和消費速度是不同的。這就需要讓

生產者消費者問題Java三種實現

read 可執行 tran extend 模式 fit ner consumer 傳輸數據 生產者-消費者Java實現 2017-07-27 1 概述 生產者消費者問題是多線程的一個經典問題，它描述是有一塊緩沖區作為倉庫，生產者可以將產品放入倉庫，消費者則可

生產者與消費者的Java實現

pri version per hello security pac rds 生成 thread 首先創建maven工程，需要引入的包： <dependencies> <dependency> <groupId>

java——利用生產者消費者模式思想實現簡易版handler機制

參考教程：http://www.sohu.com/a/237792762_659256 首先介紹每一個類： 1.Message： 　　這個類的作用是儲存一個生產者生產出來的具體的訊息，就類似連結串列佇列中的一個節點，自行定義需要儲存的內容。 　　code：訊息要執行的具體動作程式碼 　　msg：訊息

【Java併發】生產者-消費者模式簡單實現（模擬訊息佇列）

簡單的模擬了一個訊息佇列 Producer：生產者 Consumer：消費者 Message：訊息體 import java.util.concurrent.ArrayBlockingQueue; import java.util.c

【Java】生產者消費者模式的實現

前言 生產者消費者問題是執行緒模型中的經典問題：生產者和消費者在同一時間段內共用同一儲存空間，生產者向空間裡生產資料，而消費者取走資料。 阻塞佇列就相當於一個緩衝區，平衡了生產者和消費者的處理能力。這個阻塞佇列就是用來給生產者和消費者解耦的。 wa

多線程-生產者消費者（BlockingQueue實現）

insert inter exceptio ted 不同的 方法 nta 條件 -i 三、采用BlockingQueue實現 BlockingQueue也是java.util.concurrent下的主要用來控制線程同步的工具。 BlockingQueue有四個具體的實現類

大話資料結構（五）——棧的兩種java實現方式

在我們生活當中經常會看到這樣一種操作，比如我們往一個空羽毛球盒子裡面放羽毛球（個人比較喜歡羽毛球，嘿嘿），放完後再將羽毛球一個一個取出的時候會發現，最先放進去的羽毛球往往最後才取出來，相反，最後放入的羽毛球往往最先取出。這個例子形象的說明了棧的操作方式，下面我們來看看什麼是棧，以及棧的一些操

資料結構(二)--- 線性錶鏈表(單鏈表)java實現方式

線性表的鏈式儲存結構：所有元素不考慮相鄰位置，哪有空位置就到那裡，而只是讓每個元素知道它下一個元素的位置在那裡，這樣，我們可以在第一個元素時，就知道第二個元素的位置(記憶體地址)，而找到它；在第二個元素時，再找到第三個元素的位置，這樣所有的元素就可以通過遍歷而找到。 連結串列中的第

將一句話中的單詞倒置，標點符號不變。Java實現方式

在網上看到一道這樣的題目，例如輸入 i can fly. 輸出fly. can i 於是自己實現了一下。 List<String>list=new ArrayList<>(); String s="i can fly

JAVA#實現方式執行多執行緒 札記

public static void main(String[] args) { Shixian s1=new Shixian(); Thread t1=new Thread(s1); t1.setName("宋小艾"); t1.st

生產者消費者問題Java原始碼示例

生產者消費者問題 本示例僅供參考，歡迎提出問題，進行交流 import java.util.LinkedList; class Storage{ private static final int MAX = 100; Lin

BlockingQueue的實現、使用 以及 生產者消費者的BlockingQueue實現

BlockingQueue BlockingQueue介面主要實現： 主要有ArrayBlockingQueue（基於陣列，有界佇列）、LinkedBlockingQueue（無界佇列）。 關鍵是在Blocking上，它會讓服務執行緒在佇列為空時，

CXF系列之JAX-WS規範的java實現方式

package com.test.client; import java.text.ParseException; import java.text.SimpleDateFormat; import org.apache.cxf.jaxws.JaxWsProxyFactoryBean; import c

執行緒安全的生產者消費者四種實現方法

問題描述 在IT技術面試過程中，我們經常會遇到生產者消費者問題(Producer-consumer problem)， 這是多執行緒併發協作問題的經典案例。場景中包含三個物件，生產者(Producer)，消費者(Consumer)以及一個固定大小的緩衝區(Buffer)。生產者的主要作用是不斷生成資料放到緩衝

Java多執行緒-----實現生產者消費者模式的幾種方式

   1 生產者消費者模式概述      生產者消費者模式就是通過一個容器來解決生產者和消費者的強耦合問題。生產者和消費者彼此之間不直接通訊，而通過阻塞佇列來進行通訊，所以生產者生產完資料之後不用等待消費者處理， 直接扔給阻塞佇列，消費者不找生產者要資料，