1. class Resource
   
2. {
   
3.         private String name;
   
4.         private int count = 1;
   
5.         private boolean flag = false;
   
6.         public synchronized void set(String name)
   
7.         {
   
8.                 if(flag) {
   
9.                         try{this.wait();}catch(InterruptedException e){}
   
10.                 } else {//老师讲的是用while来判断防止生产一个消费多个的问题，我这样用if else 来判断是不是也可以也不会出现安全问题               
    
11.                         this.name = name + count;
    
12.                         count++;
    
13.                         System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
    
14.                         flag = true;
    
15.                         notifyAll();
    
16.                 }
    
17.         }
    
18. 
    
19.         public synchronized void out()//  t3
    
20.         {
    
21.                 if(!flag) {
    
22.                         try{this.wait();}catch(InterruptedException e){}
    
23.                 }else {
    
24.                         System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
    
25.                         flag = false;
    
26.                         notifyAll();
    
27.                 }
    
28.         }
    
29. }
    
30. 
    
31. class Producer implements Runnable
    
32. {
    
33.         private Resource r;
    
34.         Producer(Resource r)
    
35.         {
    
36.                 this.r = r;
    
37.         }
    
38.         public void run()
    
39.         {
    
40.                 while(true)
    
41.                 {
    
42.                         r.set("烤鸭");
    
43.                 }
    
44.         }
    
45. }
    
46. 
    
47. class Consumer implements Runnable
    
48. {
    
49.         private Resource r;
    
50.         Consumer(Resource r)
    
51.         {
    
52.                 this.r = r;
    
53.         }
    
54.         public void run()
    
55.         {
    
56.                 while(true)
    
57.                 {
    
58.                         r.out();
    
59.                 }
    
60.         }
    
61. }
    
62. 
    
63. 
    
64. 
    
65. class  ProducerConsumerDemo
    
66. {
    
67.         public static void main(String[] args)
    
68.         {
    
69.                 Resource r = new Resource();
    
70.                 Producer pro = new Producer(r);
    
71.                 Consumer con = new Consumer(r);
    
72. 
    
73.                 Thread t0 = new Thread(pro);
    
74.                 Thread t1 = new Thread(pro);
    
75.                 Thread t2 = new Thread(con);
    
76.                 Thread t3 = new Thread(con);
    
77.                 t0.start();
    
78.                 t1.start();
    
79.                 t2.start();
    
80.                 t3.start();
    
81. 
    
82.         }
    
83. }
    
84. 
    

复制代码

我这样用if else是不是也可以避免出现生产一个消费多个的问题，自己写的时候这样写了感觉应该也没问题，不大肯定，帮忙看看，谢谢

//老师讲的是用while来判断防止生产一个消费多个的问题，我这样用if else 来判断是不是也可以也不会出现安全问题
这个问题，最好用while语句，while语句能防止伪唤醒的情况。伪唤醒发生的定义是一个线程不是被别的线程唤醒、不是被别的线程中断、或者超时，而被唤醒叫做伪唤醒。至于想具体了解什么是伪唤醒，自己可以查查文档，也可以看看张孝祥讲的jdk1.5的线程并发库的视频第4课31分钟开始看，里面有讲过。我的理解采用了老张的说法，就是你睡着了，可能不是你被别人叫醒的，有可能你是被噩梦惊醒的。