[关闭]
@lzb1096101803 2016-03-10T11:01:22.000000Z 字数 4587 阅读 398

BlockingQueue的使用,生产者消费者

电话面试


1.BlockingQueue定义的常用方法如下:
1)add(anObject):把anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则报异常
2)offer(anObject):表示如果可能的话,将anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则返回false.
3)put(anObject):把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续. 会直接返回false。
4)poll(time):取走BlockingQueue里排在首位的对象,若不能立即取出,则可以等time参数规定的时间,取不到时返回null
5)take():取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到Blocking有新的对象被加入为止

2.BlockingQueue有四个具体的实现类,根据不同需求,选择不同的实现类
1)ArrayBlockingQueue:规定大小的BlockingQueue,其构造函数必须带一个int参数来指明其大小.其所含的对象是以FIFO(先入先出)顺序排序的.
2)LinkedBlockingQueue:大小不定的BlockingQueue,若其构造函数带一个规定大小的参数,生成的BlockingQueue有大小限制,若不带大小参数,所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定.其所含的对象是以FIFO(先入先出)顺序排序的
3)PriorityBlockingQueue:类似于LinkedBlockQueue,但其所含对象的排序不是FIFO,而是依据对象的自然排序顺序或者是构造函数的Comparator决定的顺序.
4)SynchronousQueue:特殊的BlockingQueue,对其的操作必须是放和取交替完成的.

具体实现
(1)wait() / notify()方法
(2)await() / signal()方法
(3)BlockingQueue阻塞队列方法
(4)PipedInputStream / PipedOutputStream

http://blog.csdn.net/monkey_d_meng/article/details/6251879

这里列出第一钟

  1. import java.util.LinkedList;
  2. /**
  3. * 仓库类Storage实现缓冲区
  4. *
  5. * Email:530025983@qq.com
  6. *
  7. * @author MONKEY.D.MENG 2011-03-15
  8. *
  9. */
  10. public class Storage
  11. {
  12. // 仓库最大存储量
  13. private final int MAX_SIZE = 100;
  14. // 仓库存储的载体
  15. private LinkedList<Object> list = new LinkedList<Object>();
  16. // 生产num个产品
  17. public void produce(int num)
  18. {
  19. // 同步代码段
  20. synchronized (list)
  21. {
  22. // 如果仓库剩余容量不足
  23. while (list.size() + num > MAX_SIZE)
  24. {
  25. System.out.println("【要生产的产品数量】:" + num + "/t【库存量】:"
  26. + list.size() + "/t暂时不能执行生产任务!");
  27. try
  28. {
  29. // 由于条件不满足,生产阻塞
  30. list.wait();
  31. }
  32. catch (InterruptedException e)
  33. {
  34. e.printStackTrace();
  35. }
  36. }
  37. // 生产条件满足情况下,生产num个产品
  38. for (int i = 1; i <= num; ++i)
  39. {
  40. list.add(new Object());
  41. }
  42. System.out.println("【已经生产产品数】:" + num + "/t【现仓储量为】:" + list.size());
  43. list.notifyAll();
  44. }
  45. }
  46. // 消费num个产品
  47. public void consume(int num)
  48. {
  49. // 同步代码段
  50. synchronized (list)
  51. {
  52. // 如果仓库存储量不足
  53. while (list.size() < num)
  54. {
  55. System.out.println("【要消费的产品数量】:" + num + "/t【库存量】:"
  56. + list.size() + "/t暂时不能执行生产任务!");
  57. try
  58. {
  59. // 由于条件不满足,消费阻塞
  60. list.wait();
  61. }
  62. catch (InterruptedException e)
  63. {
  64. e.printStackTrace();
  65. }
  66. }
  67. // 消费条件满足情况下,消费num个产品
  68. for (int i = 1; i <= num; ++i)
  69. {
  70. list.remove();
  71. }
  72. System.out.println("【已经消费产品数】:" + num + "/t【现仓储量为】:" + list.size());
  73. list.notifyAll();
  74. }
  75. }
  76. // get/set方法
  77. public LinkedList<Object> getList()
  78. {
  79. return list;
  80. }
  81. public void setList(LinkedList<Object> list)
  82. {
  83. this.list = list;
  84. }
  85. public int getMAX_SIZE()
  86. {
  87. return MAX_SIZE;
  88. }
  89. }
  90. /**
  91. * 生产者类Producer继承线程类Thread
  92. *
  93. * Email:530025983@qq.com
  94. *
  95. * @author MONKEY.D.MENG 2011-03-15
  96. *
  97. */
  98. public class Producer extends Thread
  99. {
  100. // 每次生产的产品数量
  101. private int num;
  102. // 所在放置的仓库
  103. private Storage storage;
  104. // 构造函数,设置仓库
  105. public Producer(Storage storage)
  106. {
  107. this.storage = storage;
  108. }
  109. // 线程run函数
  110. public void run()
  111. {
  112. produce(num);
  113. }
  114. // 调用仓库Storage的生产函数
  115. public void produce(int num)
  116. {
  117. storage.produce(num);
  118. }
  119. // get/set方法
  120. public int getNum()
  121. {
  122. return num;
  123. }
  124. public void setNum(int num)
  125. {
  126. this.num = num;
  127. }
  128. public Storage getStorage()
  129. {
  130. return storage;
  131. }
  132. public void setStorage(Storage storage)
  133. {
  134. this.storage = storage;
  135. }
  136. }
  137. /**
  138. * 消费者类Consumer继承线程类Thread
  139. *
  140. * Email:530025983@qq.com
  141. *
  142. * @author MONKEY.D.MENG 2011-03-15
  143. *
  144. */
  145. public class Consumer extends Thread
  146. {
  147. // 每次消费的产品数量
  148. private int num;
  149. // 所在放置的仓库
  150. private Storage storage;
  151. // 构造函数,设置仓库
  152. public Consumer(Storage storage)
  153. {
  154. this.storage = storage;
  155. }
  156. // 线程run函数
  157. public void run()
  158. {
  159. consume(num);
  160. }
  161. // 调用仓库Storage的生产函数
  162. public void consume(int num)
  163. {
  164. storage.consume(num);
  165. }
  166. // get/set方法
  167. public int getNum()
  168. {
  169. return num;
  170. }
  171. public void setNum(int num)
  172. {
  173. this.num = num;
  174. }
  175. public Storage getStorage()
  176. {
  177. return storage;
  178. }
  179. public void setStorage(Storage storage)
  180. {
  181. this.storage = storage;
  182. }
  183. }
  184. /**
  185. * 测试类Test
  186. *
  187. * Email:530025983@qq.com
  188. *
  189. * @author MONKEY.D.MENG 2011-03-15
  190. *
  191. */
  192. public class Test
  193. {
  194. public static void main(String[] args)
  195. {
  196. // 仓库对象
  197. Storage storage = new Storage();
  198. // 生产者对象
  199. Producer p1 = new Producer(storage);
  200. Producer p2 = new Producer(storage);
  201. Producer p3 = new Producer(storage);
  202. Producer p4 = new Producer(storage);
  203. Producer p5 = new Producer(storage);
  204. Producer p6 = new Producer(storage);
  205. Producer p7 = new Producer(storage);
  206. // 消费者对象
  207. Consumer c1 = new Consumer(storage);
  208. Consumer c2 = new Consumer(storage);
  209. Consumer c3 = new Consumer(storage);
  210. // 设置生产者产品生产数量
  211. p1.setNum(10);
  212. p2.setNum(10);
  213. p3.setNum(10);
  214. p4.setNum(10);
  215. p5.setNum(10);
  216. p6.setNum(10);
  217. p7.setNum(80);
  218. // 设置消费者产品消费数量
  219. c1.setNum(50);
  220. c2.setNum(20);
  221. c3.setNum(30);
  222. // 线程开始执行
  223. c1.start();
  224. c2.start();
  225. c3.start();
  226. p1.start();
  227. p2.start();
  228. p3.start();
  229. p4.start();
  230. p5.start();
  231. p6.start();
  232. p7.start();
  233. }
  234. }
  235. 【要消费的产品数量】:50 【库存量】:0 暂时不能执行生产任务!
  236. 【要消费的产品数量】:30 【库存量】:0 暂时不能执行生产任务!
  237. 【要消费的产品数量】:20 【库存量】:0 暂时不能执行生产任务!
  238. 【已经生产产品数】:10 【现仓储量为】:10
  239. 【要消费的产品数量】:20 【库存量】:10 暂时不能执行生产任务!
  240. 【要消费的产品数量】:30 【库存量】:10 暂时不能执行生产任务!
  241. 【要消费的产品数量】:50 【库存量】:10 暂时不能执行生产任务!
  242. 【已经生产产品数】:10 【现仓储量为】:20
  243. 【要消费的产品数量】:50 【库存量】:20 暂时不能执行生产任务!
  244. 【要消费的产品数量】:30 【库存量】:20 暂时不能执行生产任务!
  245. 【已经消费产品数】:20 【现仓储量为】:0
  246. 【已经生产产品数】:10 【现仓储量为】:10
  247. 【已经生产产品数】:10 【现仓储量为】:20
  248. 【已经生产产品数】:80 【现仓储量为】:100
  249. 【要生产的产品数量】:10 【库存量】:100 暂时不能执行生产任务!
  250. 【已经消费产品数】:30 【现仓储量为】:70
  251. 【已经消费产品数】:50 【现仓储量为】:20
  252. 【已经生产产品数】:10 【现仓储量为】:30
  253. 【已经生产产品数】:10 【现仓储量为】:40
添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注