1. package com.qianfeng.test;
   
2. 
   
3. import java.util.Comparator;
   
4. import java.util.Random;
   
5. import java.util.TreeSet;
   
6. 
   
7. /**
   
8. * 题是我自己想的
   
9. *
   
10. * 一个工厂由多个生产者组成，每一天生产随机数目的产品，（由于天气等不可抗拒因素）
    
11. * 由多个商店负责销售这些产品，也是随机销售产品数目（由于天气，消费者心情，是不是周末等因素），但不能超过库存
    
12. * 销售必须从先生产的产品开始
    
13. *
    
14. *
    
15. * @author Administrator
    
16. *
    
17. */
    
18. 
    
19. /**
    
20. * 比较器用来使产品不重复
    
21. *
    
22. * @author Administrator
    
23. *
    
24. */
    
25. class ComByProduceNumber implements Comparator<Produce> {
    
26. 
    
27.         @Override
    
28.         public int compare(Produce o1, Produce o2) {
    
29.                 // TODO Auto-generated method stub
    
30.                 return o1.getProduceNumber().compareTo(o2.getProduceNumber());
    
31.         }
    
32. }
    
33. 
    
34. /**
    
35. * 仓库类
    
36. *
    
37. * @author Administrator
    
38. *
    
39. */
    
40. class Warehouse {
    
41.         // 定义集合用来装产品
    
42.         private TreeSet<Produce> ts = new TreeSet<Produce>(new ComByProduceNumber());
    
43.         // 定义一个标记
    
44.         private boolean flag;
    
45.        
    
46. 
    
47.         public boolean isFlag() {
    
48.                 return flag;
    
49.         }
    
50. 
    
51.         public void setFlag(boolean flag) {
    
52.                 this.flag = flag;
    
53.         }
    
54. 
    
55.         public void add(Produce produce) {
    
56.                 ts.add(produce);
    
57.         }
    
58. 
    
59.         public Produce get() {
    
60.                 return ts.pollFirst();
    
61.         }
    
62. 
    
63. }
    
64. 
    
65. /**
    
66. * 产品类
    
67. *
    
68. * @author Administrator
    
69. *
    
70. */
    
71. class Produce {
    
72.         // 品名
    
73.         private String produceName;
    
74.         // 编号，从0开始
    
75.         private static int count;
    
76.         // 产品系列
    
77.         private String series;
    
78.         // 产品序列号 由产品系列加产品编号组成
    
79.         private String ProduceNumber;
    
80. 
    
81.         public String getProduceName() {
    
82.                 return produceName;
    
83.         }
    
84. 
    
85.         public void setProduceName(String produceName) {
    
86.                 this.produceName = produceName;
    
87.         }
    
88. 
    
89.         public int getCount() {
    
90.                 return count;
    
91.         }
    
92. 
    
93.         public void setCount(int count) {
    
94.                 Produce.count = count;
    
95.         }
    
96. 
    
97.         public String getSeries() {
    
98.                 return series;
    
99.         }
    
100. 
     
101.         public void setSeries(String series) {
     
102.                 this.series = series;
     
103.         }
     
104. 
     
105.         public String getProduceNumber() {
     
106.                 return ProduceNumber;
     
107.         }
     
108. 
     
109.         public void setProduceNumber(String produceNumber) {
     
110.                 ProduceNumber = produceNumber;
     
111.         }
     
112. 
     
113.         public Produce(String produceName, String series) {
     
114.                 super();
     
115.                 this.produceName = produceName;
     
116.                 this.series = series;
     
117.                 ++count;
     
118.                 ProduceNumber = series + (10000 + count);
     
119.         }
     
120. }
     
121. 
     
122. /**
     
123. * http://v.yinyuetai.com/video/325227 工厂类
     
124. */
     
125. class Factory implements Runnable {
     
126.         private Warehouse warehouse;
     
127.        
     
128.        
     
129.         public Factory(Warehouse warehouse) {
     
130.                 super();
     
131.                 this.warehouse = warehouse;
     
132.         }
     
133. 
     
134.         // 随机生产的产品是数目
     
135.         private int yield;
     
136. 
     
137.         // 生产方法
     
138.         public void prodoce() {
     
139.                 if (warehouse.isFlag()) {
     
140.                         try {
     
141.                                 warehouse.wait();
     
142.                         } catch (InterruptedException e) {
     
143.                                 // TODO Auto-generated catch block
     
144.                                 e.printStackTrace();
     
145.                         }
     
146.                 }
     
147.                 synchronized (warehouse) {
     
148.                         yield = new Random().nextInt(20);
     
149.                         for (int i = 1; i <= yield; i++) {
     
150.                                 Produce produce = new Produce("Lenovo游戏影音本", "-LX-Y");
     
151.                                 warehouse.add(produce);
     
152.                                 System.out.println(Thread.currentThread().getName() + "："
     
153.                                                 + produce.getProduceName() + produce.getProduceNumber()
     
154.                                                 + "已入库");
     
155.                         }
     
156.                         try {
     
157.                                 Thread.sleep(1000);
     
158.                         } catch (InterruptedException e) {
     
159.                                 // TODO Auto-generated catch block
     
160.                                 e.printStackTrace();
     
161.                         }
     
162.                         warehouse.notify();
     
163.                         warehouse.setFlag(true);
     
164.                 }
     
165. 
     
166.         }
     
167. 
     
168.         @Override
     
169.         public void run() {
     
170.                 // TODO Auto-generated method stub
     
171.                 while (true) {
     
172.                         prodoce();
     
173.                 }
     
174.         }
     
175. 
     
176. }
     
177. 
     
178. class DirectSaleStore implements Runnable {
     
179.         private Warehouse warehouse;
     
180.        
     
181.         // 随机卖出的产品数目
     
182.         private int sale;
     
183.        
     
184.        
     
185.         public DirectSaleStore(Warehouse warehouse) {
     
186.                 super();
     
187.                 this.warehouse = warehouse;
     
188.         }
     
189. 
     
190.         // 销售方法
     
191.         public void sale() {
     
192.                 if (!warehouse.isFlag()) {
     
193.                         try {
     
194.                                 warehouse.wait();
     
195.                         } catch (InterruptedException e) {
     
196.                                 // TODO Auto-generated catch block
     
197.                                 e.printStackTrace();
     
198.                         }
     
199.                 }
     
200.                 synchronized (warehouse) {
     
201.                         sale = new Random().nextInt(30);
     
202.                         for (int i = 1; i <= sale; i++) {
     
203.                                 Produce produce = warehouse.get();
     
204.                                 if (produce == null) {
     
205.                                         System.out.println("已售完！！！");
     
206.                                         break;
     
207.                                 }
     
208.                                 System.out.println(Thread.currentThread().getName() + "："
     
209.                                                 + produce.getProduceName() + produce.getProduceNumber()
     
210.                                                 + "已卖出");
     
211.                         }
     
212.                         warehouse.setFlag(false);
     
213.                         warehouse.notify();
     
214.                 }
     
215.         }
     
216. 
     
217.         @Override
     
218.         public void run() {
     
219.                 // TODO Auto-generated method stub
     
220.                 while (true) {
     
221.                         sale();
     
222.                 }
     
223.         }
     
224. 
     
225. }
     
226. 
     
227. public class Test6 {
     
228. 
     
229.         /**
     
230.          * @param args
     
231.          */
     
232.         public static void main(String[] args) {
     
233.                 // TODO Auto-generated method stub
     
234. 
     
235.                 Warehouse warehouse = new Warehouse();
     
236.                
     
237.                 Factory line1 = new Factory(warehouse);
     
238. 
     
239.                 DirectSaleStore store1 = new DirectSaleStore(warehouse);
     
240. 
     
241.                 Thread t1 = new Thread(line1, "生产线1");
     
242.                 Thread t2 = new Thread(store1, "直营店1");
     
243. 
     
244.                 t1.start();
     
245.                 t2.start();
     
246.         }
     
247. 
     
248. }
     

复制代码

智能顶贴机制已启动.....................

这是运行结果

Exception in thread "直营店1" java.lang.IllegalMonitorStateException
        at java.lang.Object.wait(Native Method)
        at java.lang.Object.wait(Object.java:502)
        at com.qianfeng.test.DirectSaleStore.sale(Test6.java:194)
        at com.qianfeng.test.DirectSaleStore.run(Test6.java:221)
        at java.lang.Thread.run(Thread.java:745)
生产线1：Lenovo游戏影音本-LX-Y10001已入库
生产线1：Lenovo游戏影音本-LX-Y10002已入库
生产线1：Lenovo游戏影音本-LX-Y10003已入库
生产线1：Lenovo游戏影音本-LX-Y10004已入库
生产线1：Lenovo游戏影音本-LX-Y10005已入库
生产线1：Lenovo游戏影音本-LX-Y10006已入库
生产线1：Lenovo游戏影音本-LX-Y10007已入库
生产线1：Lenovo游戏影音本-LX-Y10008已入库
生产线1：Lenovo游戏影音本-LX-Y10009已入库
生产线1：Lenovo游戏影音本-LX-Y10010已入库
生产线1：Lenovo游戏影音本-LX-Y10011已入库
生产线1：Lenovo游戏影音本-LX-Y10012已入库
生产线1：Lenovo游戏影音本-LX-Y10013已入库
生产线1：Lenovo游戏影音本-LX-Y10014已入库
生产线1：Lenovo游戏影音本-LX-Y10015已入库
Exception in thread "生产线1" java.lang.IllegalMonitorStateException
        at java.lang.Object.wait(Native Method)
        at java.lang.Object.wait(Object.java:502)
        at com.qianfeng.test.Factory.prodoce(Test6.java:141)
        at com.qianfeng.test.Factory.run(Test6.java:172)
        at java.lang.Thread.run(Thread.java:745)