毕老师的生产者消费者例子：多个线程生产多个线程消费，老师讲到问题出现一个商品多消费或者漏消费商品是因为唤醒后没有再次判断标志，我第一时间想到的再在判断一次就是用两个if我尝试试了下没问题但是有没有点资源浪费我就不太清楚了，讲到while解决会出现全部睡死的时候，我又想到了把notify拿到while里面去。让他临等待之前唤醒一个。但是还是出现了程序死这是怎么回事我想不明白

1. class  ProducerCunsumer
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Resource r = new Resource();
   
6.                 Thread t1 = new Thread(new Producer(r));
   
7.                 Thread t2 = new Thread(new Producer(r));
   
8.                 Thread t3 = new Thread(new Cunsumer(r));
   
9.                 Thread t4 = new Thread(new Cunsumer(r));
   
10.                 t1.start();
    
11.                 t2.start();
    
12.                 t3.start();
    
13.                 t4.start();
    
14.                
    
15.         }
    
16. }
    
17. class Resource
    
18. {
    
19.         private String name;
    
20.         private int  count = 0;
    
21.         private boolean flg = false;
    
22.         public synchronized void set(String name)
    
23.         {
    
24.                 while(flg)
    
25.                 {
    
26.                         this.notify();
    
27.                         try{wait();}catch (Exception e){}
    
28.                 }                        
    
29.                 this.name = name;
    
30.            count++;
    
31.                 System.out.println(Thread.currentThread().getName()+"。。。生产者。。。"+name+count);
    
32.                
    
33.                 flg = true;        
    
34.         }
    
35.         public synchronized void out ()
    
36.         {
    
37.                 while(!flg)
    
38.                 {
    
39.                         this.notify();
    
40.                         try{wait();}catch (Exception e){}
    
41.                 }
    
42.                 System.out.println(Thread.currentThread().getName()+"。。消费者。。"+name+count);
    
43.                 flg = false;        
    
44.         }
    
45. }
    
46. class Producer implements Runnable
    
47. { private Resource r;
    
48.         Producer(Resource r)
    
49.         {
    
50.                 this.r = r;
    
51.         }
    
52.   public void run()
    
53.         {
    
54.           while (true)
    
55.           {
    
56.                   r.set("商品");
    
57.           }
    
58.          
    
59.         }
    
60. 
    
61. }
    
62. class Cunsumer implements Runnable
    
63. { private Resource r;
    
64.         Cunsumer(Resource r)
    
65.         {
    
66.                 this.r = r;
    
67.         }
    
68.   public void run()
    
69.         {
    
70.           while (true)
    
71.                 {        
    
72.                         r.out();
    
73.                 }
    
74.         }
    
75. 
    
76. }

复制代码

while(!flg)
                {
                        this.notify();

//想明白点了，这里是两句，cpu在这里切换执行权就会出问题
                        try{wait();}catch (Exception e){}
}

这个。。。。。{:soso_e127:}

本身的生产者线程与 其他的阻塞状态消费者线程都给唤醒了，cpu执行切换到生产者，就产生了虚假唤醒...