为什么 wait()、notify()和notifyAll()方法只能在同步函数或同步代码块中使用？

1. public class Test{
   
2.         public static void main(String[] args){
   
3.                 Resource resource = new Resource();
   
4.                 Runnable r1 = new Input(resource);
   
5.                 Runnable r2 = new Output(resource);
   
6.                
   
7.                 new Thread(r1).start();
   
8.                 new Thread(r2).start();
   
9.         }
   
10. }
    
11. 
    
12. class Resource{
    
13.         public String name;
    
14.         public String sex;
    
15.         public boolean flag=false;
    
16. }
    
17. 
    
18. class Input implements Runnable{
    
19.         private Resource resource;
    
20.         public Input(Resource resource){
    
21.                 this.resource = resource;
    
22.         }
    
23.         
    
24.         public void run(){
    
25.                 int x = 0;
    
26.                 while (true){
    
27.                         synchronized(resource){
    
28.                                 if (resource.flag){
    
29.                                         try{
    
30.                                                 resource.wait();//这个为什么必须写在同步中？
    
31.                                         }catch(Exception e){
    
32.                                         }
    
33.                                 }
    
34.                                 if (0 == x){
    
35.                                         resource.name = "mike";
    
36.                                         resource.sex = "male";
    
37.                                 }else {
    
38.                                         resource.name = "丽丽";
    
39.                                         resource.sex = "女";
    
40.                                 }
    
41.                                 x = (x+1)%2;
    
42.                                 resource.flag = true;
    
43.                                 resource.notify();//这个为什么必须写在同步中？
    
44.                         }
    
45.                 }
    
46.         }
    
47. }
    
48. 
    
49. class Output implements Runnable {
    
50.         private Resource resource;
    
51.         
    
52.         public Output(Resource resource){
    
53.                 this.resource = resource;
    
54.         }
    
55.         
    
56.         public void run(){
    
57.                 while (true){
    
58.                         synchronized(resource){
    
59.                                 if (!resource.flag){
    
60.                                         try{
    
61.                                                 resource.wait();
    
62.                                         }catch(Exception e){
    
63.                                         }
    
64.                                 }
    
65.                                 System.out.println("name = " + resource.name + "  sex = " + resource.sex);
    
66.                                 resource.flag = false;
    
67.                                 resource.notify();
    
68.                         }
    
69.                 }
    
70.         }
    
71. }

复制代码

因为wait notify notify 在使用的时候需要一个监视器对象就是锁   
在API文档中有说明   

a767175432 发表于 2013-7-15 17:02
因为wait notify notify 在使用的时候需要一个监视器对象就是锁   
在API文档中有说明     ...

为什么要这样设计呢？

a767175432 发表于 2013-7-15 17:02
因为wait notify notify 在使用的时候需要一个监视器对象就是锁   
在API文档中有说明     ...

为什么要这样设计呢？

a767175432 发表于 2013-7-15 17:02
因为wait notify notify 在使用的时候需要一个监视器对象就是锁   
在API文档中有说明     ...

为什么要这样设计呢？

赵太云 发表于 2013-7-15 17:11
为什么要这样设计呢？

加入多个线程都操作统一资源 这一资源加上一把锁  
设1 2.....n个线程来操作
如果一个线程遇到了wait等待了
另一个线程用notify（）来唤醒等待的线程  
假如没有锁 那么那个线程就不知道唤醒哪个线程了。

或者一个线程在A锁上挂起，另一个线程持有B锁，那么他只能唤醒B锁上挂起的线程，不会唤醒A锁上挂起的线程

这就是要这么设计

当前的线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。

对于某一个参数的版本，实现中断和虚假唤醒是可能的，而且此方法应始终在循环中使用：

1. synchronized (obj) {
   
2. while (<condition does not hold>)
   
3. obj.wait();
   
4. ... // Perform action appropriate to condition
   
5.      }

复制代码

此方法只应由作为此对象监视器的所有者的线程来调用

注意最后一句： 此方法只应由作为此对象监视器的所有者的线程来调用。如果不给当前对象加锁，你无法拥有当前对象。

闲人忙啊 发表于 2013-7-15 18:08
当前的线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法 ...

该线程发布对此监视器的所有权并等待？？
  wait()方法不是释放了锁的吗？