Java多線程總結六：經典生產者消費者問題實現

這是個線程同步的經典例子，源代碼如下：

1. package demo.thread;  
2.   
3. /** 
4.  *經典生產者與消費者問題：生產者不斷的往倉庫中存放產品，消費者從倉庫中消費產品。 
5.  *其中生產者和消費者都可以有若干個。倉庫容量有限，庫滿時不能存放，庫空時不能取產品  
6.  */  
7.   
8. public class ProducersAndConsumers {  
9.     public static void main(String[] args) {  
10.         Storage storage = new Storage();  
11.         Thread consumer = new Thread(new Consumer(storage));  
12.         consumer.setName("消費者");  
13.         Thread producer = new Thread(new Producer(storage));  
14.         producer.setName("生產者");  
15.         consumer.start();  
16.         producer.start();  
17.     }  
18. }  
19.   
20. /** 
21.  * 消費者 
22.  */  
23. class Consumer implements Runnable {  
24.     private Storage storage;  
25.   
26.     public Consumer(Storage storage) {  
27.         this.storage = storage;  
28.     }  
29.   
30.     @Override  
31.     public void run() {  
32.         storage.pop();  
33.     }  
34. }  
35.   
36. /** 
37.  * 生產者 
38.  */  
39. class Producer implements Runnable {  
40.     private Storage storage;  
41.   
42.     public Producer(Storage storage) {  
43.         this.storage = storage;  
44.     }  
45.   
46.     @Override  
47.     public void run() {  
48.         Product product = new Product("090505105", "電話");  
49.         storage.push(product);  
50.     }  
51.   
52. }  
53.   
54. /** 
55.  * 產品類 
56.  */  
57. class Product {  
58.     private String id;// 產品id   
59.     private String name;// 產品名稱   
60.   
61.     public Product(String id, String name) {  
62.         this.id = id;  
63.         this.name = name;  
64.     }  
65.   
66.     @Override  
67.     public String toString() {  
68.         return "(產品ID：" + id + " 產品名稱：" + name + ")";  
69.     }  
70.   
71.     public String getId() {  
72.         return id;  
73.     }  
74.   
75.     public void setId(String id) {  
76.         this.id = id;  
77.     }  
78.   
79.     public String getName() {  
80.         return name;  
81.     }  
82.   
83.     public void setName(String name) {  
84.         this.name = name;  
85.     }  
86.   
87. }  
88.   
89. /** 
90.  *倉庫 
91.  */  
92. class Storage {  
93.     // 倉庫容量為10   
94.     private Product[] products = new Product[10];  
95.     private int top = 0;  
96.   
97.     // 生產者往倉庫中放入產品   
98.     public synchronized void push(Product product) {  
99.         while (top == products.length) {  
100.             try {  
101.                 wait();//倉庫已滿，等待   
102.             } catch (InterruptedException e) {  
103.                 // TODO Auto-generated catch block   
104.                 e.printStackTrace();  
105.             }  
106.         }  
107.         //把產品放入倉庫   
108.         products[top++] = product;  
109.         System.out.println(Thread.currentThread().getName() + " 生產了產品"  
110.                 + product);  
111.         notifyAll();//喚醒等待線程   
112.   
113.     }  
114.   
115.     // 消費者從倉庫中取出產品   
116.     public synchronized Product pop() {  
117.         while (top == 0) {  
118.             try {  
119.                 wait();//倉庫空，等待   
120.             } catch (InterruptedException e) {  
121.                 // TODO Auto-generated catch block   
122.                 e.printStackTrace();  
123.             }  
124.   
125.         }  
126.   
127.         //從倉庫中取產品   
128.         --top;  
129.         Product p = new Product(products[top].getId(), products[top].getName());  
130.         products[top] = null;  
131.         System.out.println(Thread.currentThread().getName() + " 消費了產品" + p);  
132.         notifyAll();//喚醒等待線程   
133.         return p;  
134.     }  
135. }  

運行結果：

生產者 生產了產品(產品ID：090505105 產品名稱：電話)
消費者 消費了產品(產品ID：090505105 產品名稱：電話)