在毕老师讲的生产者和消费者问题里，用了同步函数，生产者和消费者两个同步函数用的是同一把锁this，每个同步函数里都有等待唤醒机制，都用了wait（），但是如果当生产者进入生产者的同步函数后，执行了wait（）方法，被阻塞后，它仍然在同步函数里，这样我认为消费者就进不去消费者的同步函数了，因为他们用的是同一把this锁，但是实际上消费者还可以进去进行消费，这个怎么理解!

1. <p>class ProducerConsumerDemo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Resource r = new Resource();
   
6. 
   
7.                 Producer pro = new Producer(r);
   
8.                 Consumer con = new Consumer(r);
   
9. 
   
10.                 Thread t1 = new Thread(pro);</p><p>Thread t2 = new Thread(con);
    
11.   
    
12. 
    
13. t1.start();
    
14.                 t2.start();
    
15.   
    
16.         }
    
17. }
    
18. class Resource
    
19. {
    
20.         private String name;
    
21.         private int count = 1;
    
22.         private boolean flag = false;</p><p>
    
23. public synchronized void set(String name)
    
24.         {
    
25. if(flag)
    
26.                         try{this.wait();}catch(Exception e){}//<font color="#ff0000">假如生产者执行到这里被阻塞，但是生产者进入了同步函数，用的是ths这把锁。所以消费者应该就进不去消费者的同步函数了。但是实际上消费者还是可以进去的，怎么理解！</font>
    
27.          this.name = name+"--"+count++;
    
28. 
    
29.                 System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
    
30.                 flag = true;
    
31.                 this.notifyAll();
    
32.         }
    
33. 
    
34. public synchronized void out()//<font color="red">生产者被阻塞在生产者的同步函数里，但是消费者还可以进入消费者的同步函数，消费者用的也是this这把锁。</font>
    
35.         {
    
36. if(!flag)
    
37.                         try{wait();}catch(Exception e){}
    
38.          System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
    
39.                 flag = false;
    
40.                 this.notifyAll();
    
41.         }
    
42. }
    
43. 
    
44. class Producer implements Runnable
    
45. {
    
46.         private Resource res;
    
47. 
    
48.         Producer(Resource res)
    
49.         {
    
50.                 this.res = res;
    
51.         }
    
52.         public void run()
    
53.         {
    
54.                 while(true)
    
55.                 {
    
56.                         res.set("+商品+");
    
57.                 }
    
58.         }
    
59. }
    
60. 
    
61. class Consumer implements Runnable
    
62. {
    
63.         private Resource res;
    
64. 
    
65.         Consumer(Resource res)
    
66.         {
    
67.                 this.res = res;
    
68.         }
    
69.         public void run()
    
70.         {
    
71.                 while(true)
    
72.                 {
    
73.                         res.out();
    
74.                 }
    
75.         }
    
76. }</p>

复制代码

LZ可以看一下API里关于wait()方法的说明，有这样一句：
“当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。”
这也是wait和sleep的重要区别，执行到wait的线程会把执行权释放给共用本锁的其他线程，而sleep不会。

受教了。当时看那句话时，没理解，最后反复思考，终于搞明白了！