生产者消费者问题

一、先处理只有1个生产者和1个消费者的情况

二、再处理2个生产者和2个消费者的情况

对于一、
步骤：
1 建立一个资源类，包含成员变量（商品名称，商品编号、监视器）
和方法（设置商品名称和商品编号）

2 建立生产者类，实现Runnable接口，覆盖run方法

3 建立消费者类，实现Runnable接口，覆盖run方法

1. //1个消费者线程和1个生产者线程
   
2. class Resource
   
3. {
   
4.         private String name;//商品名称
   
5.         private int count=1;//商品编号
   
6.         private boolean flag = false;//监视器
   
7.        
   
8.         //设置商品名称，编号自动加1
   
9.         public synchronized void set(String name)
   
10.         {
    
11.                 if(flag)//如果资源监视器为真，那么调用本方法的对象等待
    
12.                         try
    
13.                         {
    
14.                                 this.wait();
    
15.                         }
    
16.                         catch (Exception e)
    
17.                         {
    
18.                         }
    
19.                                 this.name = name;
    
20.                                  count++;
    
21.                                  System.out.println(Thread.currentThread().getName()+"..."+name+"...生产者...编号:"+count);
    
22.                                 flag = true;
    
23.                                 this.notify();//唤醒线程池中的第一个线程
    
24.         }
    
25. 
    
26.         //获取商品名称和编号
    
27.         public synchronized void get()
    
28.         {
    
29.                 if(!flag)//如果资源监视器为假，那么调用本方法的对象等待
    
30.                 try
    
31.                 {
    
32.                         this.wait();
    
33.                 }
    
34.                 catch (Exception e)
    
35.                 {
    
36.                 }
    
37.                         System.out.println(Thread.currentThread().getName()+"..."+name+"....消费者.........编号："+count);
    
38.                         flag = false;
    
39.                         this.notify();//唤醒线程池中的第一线程
    
40.         }
    
41. 
    
42. }
    
43. 
    
44. class Producer implements Runnable
    
45. {
    
46.         private Resource r;
    
47. 
    
48.         //利用传递引用类型变量和构造函数避免造成初始化对象不唯一
    
49.         Producer(Resource r)
    
50.         {
    
51.                 this.r =r;
    
52.         }
    
53.        
    
54.         public void run()
    
55.         {
    
56.                 while(true)
    
57.                         r.set("商品");
    
58.         }
    
59. 
    
60. }
    
61. 
    
62. class Consumer implements Runnable
    
63. {
    
64.         private Resource r;
    
65. 
    
66.         Consumer(Resource r)
    
67.         {
    
68.                 this.r = r;
    
69.         }
    
70. 
    
71.         public void run()
    
72.         {
    
73.                 while(true)
    
74.                         r.get();
    
75.         }
    
76. }
    
77. 
    
78. 
    
79. 
    
80. 
    
81. 
    
82. 
    
83. class MyProducerConsumerDemo
    
84. {
    
85.         public static void main(String[] args)
    
86.         {
    
87.                 //建立资源对象
    
88.                 Resource r =new Resource();
    
89.                
    
90.                 //建立生产者对象
    
91.                 Producer p =new Producer(r);
    
92. 
    
93.                 //建立消费者对象
    
94.                 Consumer c = new Consumer(r);
    
95. 
    
96.                 //建立生产者线程
    
97.                 Thread tp1 = new Thread(p);
    
98.                
    
99.                 //建立消费者线程
    
100.                 Thread cp1 = new Thread(c);
     
101. 
     
102.                 //启动生产者线程
     
103.                 tp1.start();
     
104. 
     
105.                 //启动消费者线程
     
106.                 cp1.start();
     
107.                
     
108.                
     
109.                 //简化代码
     
110.                 //new Thread(new Producer(r)).start();
     
111.                 //new Thread(new Consumer(r)).start();
     
112.                
     
113.         }
     
114. }

复制代码

1. //两个生产者和两个消费者线程
   
2. class Resource
   
3. {
   
4.         private String name;//商品名称
   
5.         private int count=1;//商品编号
   
6.         private boolean flag = false;//监视器
   
7.        
   
8.         //设置商品名称，编号自动加1
   
9.         public synchronized void set(String name)
   
10.         {
    
11.                 //if(flag)//如果资源监视器为真，那么调用本方法的对象等待
    
12.                 while(flag)
    
13.                         try
    
14.                         {
    
15.                                 this.wait();
    
16.                         }
    
17.                         catch (Exception e)
    
18.                         {
    
19.                         }
    
20.                                 this.name = name;
    
21.                                  count++;
    
22.                                  System.out.println(Thread.currentThread().getName()+"..."+name+"...生产者...编号:"+count);
    
23.                                 flag = true;
    
24.                                 this.notifyAll();//唤醒线程池中的第一个线程
    
25.         }
    
26. 
    
27.         //获取商品名称和编号
    
28.         public synchronized void get()
    
29.         {
    
30.                
    
31.                 //if(!flag)//如果资源监视器为假，那么调用本方法的对象等待
    
32.                 while(!flag)
    
33.                 try
    
34.                 {
    
35.                         this.wait();
    
36.                 }
    
37.                 catch (Exception e)
    
38.                 {
    
39.                 }
    
40.                         System.out.println(Thread.currentThread().getName()+"..."+name+"....消费者.........编号："+count);
    
41.                         flag = false;
    
42.                         this.notifyAll();//唤醒线程池中的第一线程
    
43.         }
    
44. 
    
45. }
    
46. 
    
47. class Producer implements Runnable
    
48. {
    
49.         private Resource r;
    
50. 
    
51.         //利用传递引用类型变量和构造函数避免造成初始化对象不唯一
    
52.         Producer(Resource r)
    
53.         {
    
54.                 this.r =r;
    
55.         }
    
56.        
    
57.         public void run()
    
58.         {
    
59.                 while(true)
    
60.                         r.set("商品");
    
61.         }
    
62. 
    
63. }
    
64. 
    
65. class Consumer implements Runnable
    
66. {
    
67.         private Resource r;
    
68. 
    
69.         Consumer(Resource r)
    
70.         {
    
71.                 this.r = r;
    
72.         }
    
73. 
    
74.         public void run()
    
75.         {
    
76.                 while(true)
    
77.                         r.get();
    
78.         }
    
79. }
    
80. 
    
81. 
    
82. 
    
83. 
    
84. 
    
85. 
    
86. class MyProducerConsumerDemo
    
87. {
    
88.         public static void main(String[] args)
    
89.         {
    
90.                 //建立资源对象
    
91.                 Resource r =new Resource();
    
92. 
    
93.                 //建立生产者对象
    
94.                 Producer p =new Producer(r);
    
95. 
    
96.                 //建立消费者对象
    
97.                 Consumer c = new Consumer(r);
    
98. 
    
99.                 //建立生产者线程
    
100.                 Thread tp1 = new Thread(p);
     
101.                 Thread tp2 = new Thread(p);
     
102.                
     
103.                 //建立消费者线程
     
104.                 Thread cp1 = new Thread(c);
     
105.                 Thread cp2 = new Thread(c);
     
106. 
     
107.                 //启动生产者线程
     
108.                 tp1.start();
     
109.                 tp2.start();
     
110. 
     
111.                 //启动消费者线程
     
112.                 cp1.start();
     
113.                 cp2.start();
     
114.         }
     
115. }

复制代码

运行结果出现：
生产一次，消费2次的情况。
Thread-1...商品...生产者...编号:359
Thread-3...商品....消费者.........编号：359
Thread-2...商品....消费者.........编号：359

生产2次，消费1次的情况。
Thread-1...商品...生产者...编号:3424
Thread-0...商品...生产者...编号:3425
Thread-3...商品....消费者.........编号：3425


这说明，原来在1个生产者和1个消费者安全
但在2个生产者和2个消费者就不安全了。

为什么会这样呢？？
因为在用if语句判断的时候，当线程被唤醒后，它并没有再判断flag,
而是直接执行下一条语句，所以我们可以把if改成while。
> if(flag)//如果资源监视器为真，那么调用本方法的对象等待

改成while(flag)的时候，运行结果为：
Thread-0...商品...生产者...编号:2
Thread-3...商品....消费者.........编号：2
Thread-1...商品...生产者...编号:3
Thread-3...商品....消费者.........编号：3
Thread-0...商品...生产者...编号:4

4个线程全部处于睡眠状态，不再打印。

这又是因为睡眠呢？？
原因是notify唤醒的都是线程池中的第一个线程，
这就导致了被唤醒的线程不一定是对方的线程。
而当唤醒的是本方线程时候，线程就全部陷入了等待。
该怎么解决呢？？
可以用notifyAll();

运行结果显示安全问题被解决！

小结：
在多个生产者和多个消费者的情况下，

用while+notifyAll();

{:3_54:}自己顶一下！