生产者消费者模式和阻塞队列

这一章节我们来讨论一下阻塞队列。我们下面将通过生产者消费者模式来介绍阻塞队列。

1.什么是阻塞队列？（摘自于并发编程网对http://tutorials.jenkov.com/java-concurrency/blocking-queues.html的翻译）

当队列是空的时，从队列中获取元素的操作将会被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样，试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他的线程使队列重新变得空闲起来，如从队列中移除一个或者多个元素，或者完全清空队列，下图展示了如何通过阻塞队列来合作：

2.特性

（1）先进先出

（2）线程同步

3.下面结合生产者消费者模式来介绍阻塞队列的使用情况

[java]  view plain  copy

 

1. package com.ray.ch17;  
2.   
3. import java.util.concurrent.LinkedBlockingQueue;  
4.   
5. public class Test {  
6.   
7.     public static void main(String[] args) {  
8.         Basket basket = new Basket();  
9.         Thread thread1 = new Thread(new Chief(basket));  
10.         Thread thread2 = new Thread(new Customer(basket));  
11.         Thread thread3 = new Thread(new Customer(basket));  
12.         thread1.start();  
13.         thread2.start();  
14.         thread3.start();  
15.     }  
16. }  
17.   
18. class Cake {  
19.     private static int index = 0;  
20.     private final int id = index++;  
21.   
22.     public int getId() {  
23.         return id;  
24.     }  
25.   
26.     public Cake() {  
27.         System.out.println("生产了蛋糕,id:" + id);  
28.     }  
29. }  
30.   
31. class Chief implements Runnable {  
32.     private Basket basket = null;  
33.   
34.     public Chief(Basket basket) {  
35.         this.basket = basket;  
36.     }  
37.   
38.     public void makeCake() throws InterruptedException {  
39.         for (int i = 0; i < 20; i++) {  
40.             basket.put(new Cake());  
41.             System.out.println("现在框里面的蛋糕数量：" + basket.getQueueSize());  
42.             Thread.sleep(20);  
43.         }  
44.     }  
45.   
46.     @Override  
47.     public void run() {  
48.         try {  
49.             makeCake();  
50.         } catch (InterruptedException e) {  
51.             e.printStackTrace();  
52.         }  
53.     }  
54.   
55. }  
56.   
57. class Customer implements Runnable {  
58.     private Basket basket = null;  
59.   
60.     public Customer(Basket basket) {  
61.         this.basket = basket;  
62.     }  
63.   
64.     public void buyCake() throws InterruptedException {  
65.         System.out.println("消费了蛋糕,id:" + basket.take().getId());  
66.         System.out.println("现在框里面的蛋糕数量：" + basket.getQueueSize());  
67.     }  
68.   
69.     @Override  
70.     public void run() {  
71.         try {  
72.             for (int i = 0; i < 10; i++) {  
73.                 buyCake();  
74.                 Thread.sleep(100);  
75.             }  
76.         } catch (InterruptedException e) {  
77.             e.printStackTrace();  
78.         }  
79.     }  
80. }  
81.   
82. class Basket {  
83.     private LinkedBlockingQueue<Cake> queue = new LinkedBlockingQueue<Cake>(10);  
84.   
85.     public void put(Cake cake) throws InterruptedException {  
86.         queue.put(cake);  
87.     }  
88.   
89.     public Cake take() throws InterruptedException {  
90.         Cake cake = queue.take();  
91.         return cake;  
92.     }  
93.   
94.     public int getQueueSize() {  
95.         return queue.size();  
96.     }  
97. }  

输出：

生产了蛋糕,id:0
消费了蛋糕,id:0
现在框里面的蛋糕数量：0
现在框里面的蛋糕数量：0
生产了蛋糕,id:1
现在框里面的蛋糕数量：1
消费了蛋糕,id:1
现在框里面的蛋糕数量：0
生产了蛋糕,id:2
现在框里面的蛋糕数量：1
生产了蛋糕,id:3
现在框里面的蛋糕数量：2
生产了蛋糕,id:4
现在框里面的蛋糕数量：3
消费了蛋糕,id:2
现在框里面的蛋糕数量：2
生产了蛋糕,id:5
现在框里面的蛋糕数量：3
消费了蛋糕,id:3
现在框里面的蛋糕数量：2
生产了蛋糕,id:6
现在框里面的蛋糕数量：3
生产了蛋糕,id:7
现在框里面的蛋糕数量：4
生产了蛋糕,id:8
现在框里面的蛋糕数量：5
生产了蛋糕,id:9
现在框里面的蛋糕数量：6
消费了蛋糕,id:4
现在框里面的蛋糕数量：5
消费了蛋糕,id:5
现在框里面的蛋糕数量：4
消费了蛋糕,id:6
现在框里面的蛋糕数量：3
消费了蛋糕,id:7
现在框里面的蛋糕数量：2
消费了蛋糕,id:8
现在框里面的蛋糕数量：1
消费了蛋糕,id:9
现在框里面的蛋糕数量：0

解释：

（1）由于是生产者消费者模式，因此上面必须有生产者、消费者、篮子和消费的物品（蛋糕）这四个类，还有一个Test测试类

（2）在Cake类里面，我们使用static的index来记录每一个Cake的id

（3）在Basket类里面我们除了put和take方法，还放入一个getSize的方法来得到篮子里面现在有多少个Cake

（4）生产者和消费者其实只有一个方法就是生产make或者buy，这里面需要注意的是两个地方，第一个是数量，由于我们上面使用的是阻塞队列，因此当生产的总数量大于消费的总数量，程序就会一直在wait，只有等到下一个消费者来消费才会继续执行，反之，如果消费的数量大于生产的数量也会出现这种情况；第二个是时间，我们需要按照实际的时间匹配关系来配对时间，如果生产大于消费，在出现生产一个消费一个，需要增加生产者，如果是消费大于生产，则根据实际需求来定。

下面的代码需要等待，就是因为消费的总数大于生产的总数而出现的问题：

[java]  view plain  copy

 

1. package com.ray.ch17;  
2.   
3. import java.util.concurrent.LinkedBlockingQueue;  
4.   
5. public class Test {  
6.   
7.     public static void main(String[] args) {  
8.         Basket basket = new Basket();  
9.         Thread thread1 = new Thread(new Chief(basket));  
10.         Thread thread2 = new Thread(new Customer(basket));  
11.         Thread thread3 = new Thread(new Customer(basket));  
12.         thread1.start();  
13.         thread2.start();  
14.         thread3.start();  
15.     }  
16. }  
17.   
18. class Cake {  
19.     private static int index = 0;  
20.     private final int id = index++;  
21.   
22.     public int getId() {  
23.         return id;  
24.     }  
25.   
26.     public Cake() {  
27.         System.out.println("生产了蛋糕,id:" + id);  
28.     }  
29. }  
30.   
31. class Chief implements Runnable {  
32.     private Basket basket = null;  
33.   
34.     public Chief(Basket basket) {  
35.         this.basket = basket;  
36.     }  
37.   
38.     public void makeCake() throws InterruptedException {  
39.         for (int i = 0; i < 20; i++) {  
40.             basket.put(new Cake());  
41.             System.out.println("现在框里面的蛋糕数量：" + basket.getQueueSize());  
42.             Thread.sleep(200);  
43.         }  
44.     }  
45.   
46.     @Override  
47.     public void run() {  
48.         try {  
49.             makeCake();  
50.         } catch (InterruptedException e) {  
51.             e.printStackTrace();  
52.         }  
53.     }  
54.   
55. }  
56.   
57. class Customer implements Runnable {  
58.     private Basket basket = null;  
59.   
60.     public Customer(Basket basket) {  
61.         this.basket = basket;  
62.     }  
63.   
64.     public void buyCake() throws InterruptedException {  
65.         System.out.println("消费了蛋糕,id:" + basket.take().getId());  
66.         System.out.println("现在框里面的蛋糕数量：" + basket.getQueueSize());  
67.     }  
68.   
69.     @Override  
70.     public void run() {  
71.         try {  
72.             for (int i = 0; i < 20; i++) {  
73.                 buyCake();  
74.                 Thread.sleep(100);  
75.             }  
76.         } catch (InterruptedException e) {  
77.             e.printStackTrace();  
78.         }  
79.     }  
80. }  
81.   
82. class Basket {  
83.     private LinkedBlockingQueue<Cake> queue = new LinkedBlockingQueue<Cake>(10);  
84.   
85.     public void put(Cake cake) throws InterruptedException {  
86.         queue.put(cake);  
87.     }  
88.   
89.     public Cake take() throws InterruptedException {  
90.         Cake cake = queue.take();  
91.         return cake;  
92.     }  
93.   
94.     public int getQueueSize() {  
95.         return queue.size();  
96.     }  
97. }  

总结：这一章节我们通过生产者消费者模式来介绍了阻塞队列的特性。

这一章节就到这里，谢谢。

-----------------------------------

目录