黑马程序员技术交流社区

标题: 等待唤醒机制同步问题 [打印本页]
作者: 罗广伟    时间: 2013-6-7 11:17
标题: 等待唤醒机制同步问题
本帖最后由 罗广伟 于 2013-6-7 15:30 编辑

//等待唤醒机制代码
  1. class Res
  2. {
  3.         private String name;
  4.         private String sex;
  5.         private boolean flag = false;

  7.         public synchronized void set(String name,String sex)
  8.         {
  9.                 if(flag)
  10.                         try{this.wait();}catch(Exception e){}
  11.                 this.name = name;
  12.                
  13.                 this.sex = sex;
  14.                 flag = true;
  15.                 this.notify();
  16.         }
  17.         public synchronized void out()
  18.         {
  19.                 if(!flag)
  20.                         try{this.wait();}catch(Exception e){}
  21.                 System.out.println(name+"........"+sex);
  22.                 flag = false;
  23.                 this.notify();
  24.         }
  25. }

  27. class Input implements Runnable
  28. {
  29.         private Res r ;
  30.         Input(Res r)
  31.         {
  32.                 this.r = r;
  33.         }
  34.         public void run()
  35.         {
  36.                 int x = 0;
  37.                 while(true)
  38.                 {
  39.                         if(x==0)                                
  40.                                 r.set("mike","man");                                
  41.                         else        
  42.                                 r.set("丽丽","女女女女女");                                
  43.                         x = (x+1)%2;
  44.                 }
  45.         }
  46. }

  48. class Output implements Runnable
  49. {
  50.         private Res r ;
  51.         
  52.         Output(Res r)
  53.         {
  54.                 this.r = r;
  55.         }
  56.         public void run()
  57.         {
  58.                 while(true)
  59.                 {
  60.                         r.out();
  61.                 }
  62.         }
  63. }


  66. class  InputOutputDemo2
  67. {
  68.         public static void main(String[] args)
  69.         {
  70.                 Res r = new Res();
  71.                 Input in = new Input(r);
  72.                 Output out = new Output(r);

  74.                 Thread t1 = new Thread(in);
  75.                 Thread t2 = new Thread(out);

  77.                 t1.start();
  78.                 t2.start();
  79.         }
  80. }
复制代码
//问题：Res类中，set方法和out方法持有的锁是this，是同一个锁，那么当set方法出现等待时，因为持有this锁,out方法是无法运行的，那么程序也就死了.
//可是事实是一个等待另一个就运行，为什么呢？

作者: 刘凯    时间: 2013-6-7 11:20
排版下先
作者: hx32    时间: 2013-6-7 11:20
代码没法看啊，你插入代码，别直接复制粘贴
作者: 罗广伟    时间: 2013-6-7 11:21
hx32 发表于 2013-6-7 11:20
代码没法看啊，你插入代码，别直接复制粘贴

刚改过了，麻烦看一下
作者: hx32    时间: 2013-6-7 11:24
罗广伟 发表于 2013-6-7 11:21
刚改过了，麻烦看一下

我不会:loveliness:还没学到哪里呢
作者: 罗广伟    时间: 2013-6-7 11:29
hx32 发表于 2013-6-7 11:24
我不会还没学到哪里呢

哦，好好学吧:)
作者: 杨彬    时间: 2013-6-7 12:20
wait 和 notify 等待和唤醒的是同一个锁  每次判断后 根据你设置的开关 flag 判定是否该线程进入 等待状态 同时唤醒 同锁下等待的其他线程  两个线程交替执行  保证不死锁    如果线程多了就不好整了
作者: 罗广伟    时间: 2013-6-7 12:30
杨彬 发表于 2013-6-7 12:20
wait 和 notify 等待和唤醒的是同一个锁  每次判断后 根据你设置的开关 flag 判定是否该线程进入 等待状态  ...
  1. public synchronized void set(String name,String sex)
  2.         {
  3.                 if(flag)
  4.                         try{this.wait();}catch(Exception e){}
  5.                 this.name = name;
  6.                
  7.                 this.sex = sex;
  8.                 flag = true;
  9.                 this.notify();
  10.         }
  11.         public synchronized void out()
  12.         {
  13.                 if(!flag)
  14.                         try{this.wait();}catch(Exception e){}
  15.                 System.out.println(name+"........"+sex);
  16.                 flag = false;
  17.                 this.notify();
  18.         }
复制代码
如果程序执行到set方法wait方法时另一个线程执行out方法，这时执行set方法的线程不是持有this锁吗，那么执行out方法的线程不是不能读out方法里面的内容吗？这样程序就死了。
作者: kaka小明    时间: 2013-6-7 13:51
LZ的单对单的生产-消费模式执行流程:（1）flg=false：
作者: kaka小明    时间: 2013-6-7 14:12
发错了，不好意思。重发！
LZ的单对单的生产-消费模式执行流程:
（1）flg=false： 消费者(out)等待,锁对象的wait方法释放锁；
（2） 生产者获得锁，生产产品(set)后，产品“入库”（flg=true）,然后唤醒消费者，这时下次即使生产者再次获得了锁，由于“仓库已满”，生产者依然会等待，直到消费者取走产品；
（3）消费者获得锁，消费产品(out)后，仓库空了（flg=false）,然后唤醒消生产者，与(2)类似，消费者下次即使再次获得了锁，由于“仓库已空”消费者依然会等待，直到生产者取生产完产品；
notify和wait读会释放锁，wait释放锁后会等待，直到其他持有同样锁的线程执行notify（或者notifyAll）方法。线程执行唤醒方法后，仍可以继续竞争锁。希望你能明白，另外你继续尝试多对多的生产消费模式，这里set out方法里面用if语句是会有问题的。希望这个解释能对你有帮助哈！
作者: 罗广伟    时间: 2013-6-7 15:30
kaka小明 发表于 2013-6-7 14:12
发错了，不好意思。重发！
LZ的单对单的生产-消费模式执行流程:
（1）flg=false： 消费者(out)等待,锁对象 ...

明白了，多谢。就是wait(),sleep(),这些线程冻结状态时就会释放锁。我理解对吧？
作者: kaka小明    时间: 2013-6-7 15:37
sleep不释放锁！
作者: 罗广伟    时间: 2013-6-7 16:34
kaka小明 发表于 2013-6-7 15:37
sleep不释放锁！

哦，谢谢



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