一个关于Java线程waite()、notifyAll()的例子

一个Java解决生产者-消费者同步问题的例子，很有参考价值的。

Java代码

1. /////
2. // ProducerConsumer.java
4. //
5. // 这是个很重要的Thread例子。需要注意的是：
6. // wait() 必须在synchronized 函数或者代码块里面
7. // wait()会让已经获得synchronized 函数或者代码块控制权的Thread暂时休息，并且丧失控制权
8. // 这个时候，由于该线程丧失控制权并且进入等待，其他线程就能取得控制权，并且在适当情况下调用notifyAll()来唤醒wait()的线程。
9. // 需要注意的是，被唤醒的线程由于已经丧失了控制权，所以需要等待唤醒它的线程结束操作，从而才能重新获得控制权。
10. //
11. // 所以wait()的确是马上让当前线程丧失控制权，其他的线程可以乘虚而入。
12. //
13. // 所以wait()的使用，必须存在2个以上线程，而且必须在不同的条件下唤醒wait()中的线程。
14. //
15. //
16. // 以下的例子：
17. // ProductStack 是一个生产者跟消费者共享的同步机制，这个机制决定了什么情况生产者要wait()，什么情况消费者要wait()
18. // 可以把ProductStack看作一个产品仓库。当产品仓库满的时候，生产者线程需要wait()，从而放弃对产品仓库的控制。
19. // 这个时候消费者线程就可以进来了而取得仓库的控制权。一旦消费者消费了产品，那么仓库就不满了。
20. // 这个时候消费者线程就要notifyAll()生产者线程，让等待的生产者线程唤醒。
21. // 但是生产者被唤醒后不能马上进行生产，因为它在wait()的时候已经丧失了对仓库的控制权，所以就需要等待消费者线程结束操作，
22. // 才能重新取得仓库的控制权，再进行生产。
23. //
24. // 所以特别注意的是，notifyAll()并不是让当前线程马上让出控制权，而只是让其他wait()当中的线程唤醒而已，
25. // 所以对不起，尽管我唤醒你，可你必须还是要等我用完仓库才能进来。这点必须清楚。
26. //
27. // 相反，仓库如果空的时候，消费者线程就会wait()，然后等待生产者线程来生产产品，生产者进程乘虚而入后，让生产者线程生产产品
28. // 并且唤醒消费者线程。这个情况跟上面就类似了。
29. //
30. ///
32. public class ProducerConsumer {
34. public static void main(String[] args) {
36. ProductStack ps = new ProductStack();
38. Producer p = new Producer(ps, "生产者1");
40. Consumer c = new Consumer(ps, "消费者1");
42. new Thread(p).start();
44. new Thread(c).start();
46. }
48. }
49. class Product {
51. int id;
52. private String producedBy = "N/A";
54. private String consumedBy = "N/A";
56. // 构造函数，指明产品ID以及生产者名字。
58. Product(int id, String producedBy) {
60. this.id = id;
62. this.producedBy = producedBy;
64. }
66. // 消费，需要指明消费者名字
68. public void consume(String consumedBy) {
70. this.consumedBy = consumedBy;
72. }
74. public String toString() {
76. return "Product : " + id + ", produced by " + producedBy
78. + ", consumed by " + consumedBy;
80. }
82. public String getProducedBy() {
84. return producedBy;
86. }
88. public void setProducedBy(String producedBy) {
90. this.producedBy = producedBy;
92. }
94. public String getConsumedBy() {
96. return consumedBy;
98. }
100. public void setConsumedBy(String consumedBy) {
102. this.consumedBy = consumedBy;
104. }
105. }
107. // 这个class就是仓库，是生产者跟消费者共同争夺控制权的同步资源
109. class ProductStack {
111. int index = 0;
113. Product[] arrProduct = new Product[6];
115. // push使用来让生产者放置产品的
117. public synchronized void push(Product product) {
119. // 如果仓库满了
121. while (index == arrProduct.length) // 这里本来可以用if(),但是如果catch
123. // exception会出问题，让满的index越界
125. {
127. try {
129. // here, "this" means the thread that is using "push"
131. // so in this case it's a producer thread instance.
133. // the BIG difference between sleep() and wait() is, once
135. // wait(),
137. // the thread won't have the lock anymore
139. // so when a producer wait() here, it will lost the lock of
141. // "push()"
143. // While sleep() is still keeping this lock
145. // Important: wait() and notify() should be in "synchronized"
147. // block
149. System.out.println(product.getProducedBy() + " is waiting.");
151. // 等待，并且从这里退出push()
153. wait();
155. } catch (InterruptedException e) {
157. e.printStackTrace();
159. }
161. }
163. System.out.println(product.getProducedBy() + " sent a notifyAll().");
165. // 因为我们不确定有没有线程在wait()，所以我们既然生产了产品，就唤醒有可能等待的消费者，让他们醒来，准备消费
167. notifyAll();
169. // 注意，notifyAll()以后，并没有退出，而是继续执行直到完成。
171. arrProduct[index] = product;
173. index++;
175. System.out.println(product.getProducedBy() + " 生产了: " + product);
177. }
179. // pop用来让消费者取出产品的
181. public synchronized Product pop(String consumerName) {
183. // 如果仓库空了
185. while (index == 0) {
187. try {
189. // here will be the consumer thread instance will be waiting ,
191. // because empty
193. System.out.println(consumerName + " is waiting.");
195. // 等待，并且从这里退出pop()
197. wait();
199. } catch (InterruptedException e) {
201. e.printStackTrace();
203. }
205. }
207. System.out.println(consumerName + " sent a notifyAll().");
209. // 因为我们不确定有没有线程在wait()，所以我们既然消费了产品，就唤醒有可能等待的生产者，让他们醒来，准备生产
211. notifyAll();
213. // 注意，notifyAll()以后，并没有退出，而是继续执行直到完成。
215. // 取出产品
217. index--;
219. Product product = arrProduct[index];
221. product.consume(consumerName);
223. System.out.println(product.getConsumedBy() + " 消费了: " + product);
225. return product;
227. }
229. }
231. class Producer implements Runnable {
233. String name;
234. ProductStack ps = null;
236. Producer(ProductStack ps, String name) {
238. this.ps = ps;
240. this.name = name;
242. }
244. public void run() {
246. for (int i = 0; i < 20; i++) {
248. Product product = new Product(i, name);
250. ps.push(product);
252. try {
254. Thread.sleep((int) (Math.random() * 200));
256. } catch (InterruptedException e) {
258. e.printStackTrace();
260. }
262. }
264. }
266. }
269. class Consumer implements Runnable {
271. String name;
272. ProductStack ps = null;
273. Consumer(ProductStack ps, String name) {
275. this.ps = ps;
277. this.name = name;
279. }
281. public void run() {
283. for (int i = 0; i < 20; i++) {
285. Product product = ps.pop(name);
287. try {
289. Thread.sleep((int) (Math.random() * 1000));
291. } catch (InterruptedException e) {
293. e.printStackTrace();
295. }
297. }
299. }
301. }