消费者和生产者的例子
在本例中，有多个生产者和多个消费者。每生产一个商品，就消费一个商品，不能积压商品。
要解决的问题
1、多个生产者生产商品，要同步进行，一个生产者存储商品时，另一个生产者不能同时存储商品。
2、多个消费者消费时。要同步进行，一个消费者取商品时，另一个消费者不能同时取商品。
3、生产者在存储商品时，消费者不能取商品。
4、消费者取商品时，生产者不能存储商品。
以下是实现代码：

1. public class PorductorAndConsumer {
   
2.         public static void main(String[] args) {
   
3.                 Source s = new Source();
   
4.                 Productor p = new Productor(s);
   
5.                 Consumer c = new Consumer(s);
   
6.                
   
7.                 //两个生产者
   
8.                 new Thread(p).start();
   
9.                 new Thread(p).start();
   
10.                 //两个消费者
    
11.                 new Thread(c).start();
    
12.                 new Thread(c).start();
    
13.         }
    
14. }
    
15. class Source{
    
16.         String name;
    
17.         int count = 0;
    
18.         boolean flag = true;
    
19.         //存商品
    
20.         //synchronized:每次只能有一个生产者存商品
    
21.         public synchronized void input(String name){
    
22.                 //如果有商品，就等待消费者取走商品
    
23.                 while(flag){//***有多个生产者时，就要用while,不能用if。因为如果用if，当被阻塞进程别唤醒时，不会再次去判断生产条件flag。
    
24.                         try {this.wait();} catch (InterruptedException e) {}
    
25.                 }                       
    
26.                 this.name = name+count++;
    
27.                 System.out.println(Thread.currentThread().getName()+"***iiiii***"+this.name);
    
28.                 //有了产品
    
29.                 flag = true;
    
30.                 //就唤醒消费者
    
31.                 //有多个消费者时，就要用notifyAll()，不能用notify
    
32.                 this.notifyAll();
    
33.         }
    
34.         //取商品
    
35.         //synchronized:每次只能有一个消费者取商品
    
36.         public synchronized void output(){
    
37.                 //如果没有有商品，就等待生产者存进商品
    
38.                 while(!flag){//***有多个消费者时，就要用while,不能用if。
    
39.                         try {this.wait();} catch (InterruptedException e) {}
    
40.                 }
    
41.                 System.out.println(Thread.currentThread().getName()+"---ooooo---"+this.name);
    
42.                 //没有了产品
    
43.                 flag = false;
    
44.                 //就唤醒生产者
    
45.                 //有多个生产者时，就要用notifyAll()，不能用notify
    
46.                 this.notifyAll();
    
47.         }
    
48. }
    
49. class Productor implements Runnable{
    
50.         Source s;
    
51.         public Productor(Source s){
    
52.                 this.s = s;
    
53.         }
    
54.         public void run(){
    
55.                 //一直生产
    
56.                 while(true){
    
57.                         s.input("Productor");
    
58.                 }
    
59.         }
    
60. }
    
61. class Consumer implements Runnable{
    
62.         Source s;
    
63.         public Consumer(Source s){
    
64.                 this.s = s;
    
65.         }
    
66.         public void run(){
    
67.                 //一直消费
    
68.                 while(true){
    
69.                         s.output();
    
70.                 }
    
71.         }
    
72. }

复制代码

运行结果：

学习回顾了