黑马程序员技术交流社区

标题: 关于线程间通信的问题？ [打印本页]
作者: 赵太云    时间: 2013-7-15 15:46
标题: 关于线程间通信的问题？
本帖最后由 赵太云 于 2013-7-16 20:31 编辑

     为什么 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. }

  12. class Resource{
  13.         public String name;
  14.         public String sex;
  15.         public boolean flag=false;
  16. }

  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. }

  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. }
复制代码
作者: a767175432    时间: 2013-7-15 17:02
因为wait notify notify 在使用的时候需要一个监视器对象就是锁   
在API文档中有说明   
作者: 赵太云    时间: 2013-7-15 17:11
a767175432 发表于 2013-7-15 17:02
因为wait notify notify 在使用的时候需要一个监视器对象就是锁   
在API文档中有说明     ...

为什么要这样设计呢？
作者: 赵太云    时间: 2013-7-15 17:11
a767175432 发表于 2013-7-15 17:02
因为wait notify notify 在使用的时候需要一个监视器对象就是锁   
在API文档中有说明     ...

为什么要这样设计呢？
作者: 赵太云    时间: 2013-7-15 17:11
a767175432 发表于 2013-7-15 17:02
因为wait notify notify 在使用的时候需要一个监视器对象就是锁   
在API文档中有说明     ...

为什么要这样设计呢？
作者: a767175432    时间: 2013-7-15 18:01
赵太云 发表于 2013-7-15 17:11
为什么要这样设计呢？

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

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

这就是要这么设计
作者: 闲人忙啊    时间: 2013-7-15 18:08
当前的线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 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:39
闲人忙啊 发表于 2013-7-15 18:08
当前的线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法 ...

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



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2