看老毕的视频，其中多线程的生产者和消费者，里面讲解的一个线程等待了，另一个线程就可以进来，多线程不是有锁吗？一个线程都进来了，另一个线程应该进不来啊。。。

1. 老毕源码
   
2. //生产者消费者实例：
   
3. 
   
4. 
   
5. class ProducerConsumerDemo
   
6. {
   
7.         public static void main(String[] args)
   
8.         {
   
9.                 Resource r = new Resource();
   
10. 
    
11.                 Producer pro = new Producer(r);
    
12.                 Consumer con = new Consumer(r);
    
13. 
    
14.                 Thread t1 = new Thread(pro);
    
15.                 Thread t2 = new Thread(pro);
    
16.                 Thread t3 = new Thread(con);
    
17.                 Thread t4 = new Thread(con);
    
18. 
    
19.                 t1.start();
    
20.                 t2.start();
    
21.                 t3.start();
    
22.                 t4.start();
    
23. 
    
24.         }
    
25. }
    
26. 
    
27. /*
    
28. 对于多个生产者和消费者。
    
29. 为什么要定义while判断标记。
    
30. 原因：让被唤醒的线程再一次判断标记。
    
31. 
    
32. 
    
33. 为什么定义notifyAll，
    
34. 因为需要唤醒对方线程。
    
35. 因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
    
36. 
    
37. */
    
38. 
    
39. 
    
40. class Resource
    
41. {
    
42.         private String name;
    
43.         private int count = 1;
    
44.         private boolean flag = false;
    
45.                         //  t1    t2
    
46.         public synchronized void set(String name)
    
47.         {
    
48.                 while(flag)
    
49.                         try{this.wait();}catch(Exception e){}//t1(放弃资格)  t2(获取资格)
    
50.                 this.name = name+"--"+count++;
    
51. 
    
52.                 System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
    
53.                 flag = true;
    
54.                 this.notifyAll();
    
55.         }
    
56. 
    
57. 
    
58.         //  t3   t4  
    
59.         public synchronized void out()
    
60.         {
    
61.                 while(!flag)
    
62.                         try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格)
    
63.                 System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
    
64.                 flag = false;
    
65.                 this.notifyAll();
    
66.         }
    
67. }
    
68. 
    
69. class Producer implements Runnable
    
70. {
    
71.         private Resource res;
    
72. 
    
73.         Producer(Resource res)
    
74.         {
    
75.                 this.res = res;
    
76.         }
    
77.         public void run()
    
78.         {
    
79.                 while(true)
    
80.                 {
    
81.                         res.set("+商品+");
    
82.                 }
    
83.         }
    
84. }
    
85. 
    
86. class Consumer implements Runnable
    
87. {
    
88.         private Resource res;
    
89. 
    
90.         Consumer(Resource res)
    
91.         {
    
92.                 this.res = res;
    
93.         }
    
94.         public void run()
    
95.         {
    
96.                 while(true)
    
97.                 {
    
98.                         res.out();
    
99.                 }
    
100.         }
     
101. }
     

复制代码

在同步中,wait()线程等待之后就会释放执行资格的同时还会释放掉锁,注意这个方法只能用在同步中！
sleep()睡眠是不会释放掉锁的,所以只要它还没醒,执行完同步代码块,其他线程是不会进来的。

$love 发表于 2013-9-7 22:57
在同步中,wait()线程等待之后就会释放执行资格的同时还会释放掉锁,注意这个方法只能用在同步中！
sleep()睡 ...

非常感谢，我百度了，没有讲到这个东西的资料，可以告诉我在哪里了解的吗？

因为 wait 方法是将当前线程放入了对象的等待集中，所以它只能解除此对象的锁定
这也就能解释为什么一个线程等待了，另一个线程就可以进来。
而sleep方法呢，当前线程不丢失任何监视器(锁)的所属权
比较这两种方法的区别。

张文豪 发表于 2013-9-7 23:06
因为 wait 方法是将当前线程放入了对象的等待集中，所以它只能解除此对象的锁定
这也就能解释为什么一个线 ...

{:soso_e100:}谢谢了。

线程在wait的时候释放的执行权，也就相当于释放了锁，然后其他线程在获取执行权后就能进来了

学习学习！

wait（）方法必须用在同步当中，sleep()没有硬规定。
wait（）当线程运行到wait（）会释放锁并等待，一般是被其他线程唤醒才可以继续执行。sleep()是规定的时间到了他自然就继续运行了。

楼主，您好！

如果您的问题解决了，请把您问题的未解决更改为已解决！

谢谢合作！