//等待唤醒机制代码

1. class Res
   
2. {
   
3.         private String name;
   
4.         private String sex;
   
5.         private boolean flag = false;
   
6. 
   
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. }
    
26. 
    
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. }
    
47. 
    
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. }
    
64. 
    
65. 
    
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);
    
73. 
    
74.                 Thread t1 = new Thread(in);
    
75.                 Thread t2 = new Thread(out);
    
76. 
    
77.                 t1.start();
    
78.                 t2.start();
    
79.         }
    
80. }
    

复制代码

//问题：Res类中，set方法和out方法持有的锁是this，是同一个锁，那么当set方法出现等待时，因为持有this锁,out方法是无法运行的，那么程序也就死了.
//可是事实是一个等待另一个就运行，为什么呢？

排版下先

代码没法看啊，你插入代码，别直接复制粘贴

hx32 发表于 2013-6-7 11:20
代码没法看啊，你插入代码，别直接复制粘贴

刚改过了，麻烦看一下

罗广伟 发表于 2013-6-7 11:21
刚改过了，麻烦看一下

我不会:loveliness:还没学到哪里呢

hx32 发表于 2013-6-7 11:24
我不会还没学到哪里呢

哦，好好学吧:)

wait 和 notify 等待和唤醒的是同一个锁  每次判断后 根据你设置的开关 flag 判定是否该线程进入 等待状态 同时唤醒 同锁下等待的其他线程  两个线程交替执行  保证不死锁    如果线程多了就不好整了

杨彬 发表于 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方法里面的内容吗？这样程序就死了。

LZ的单对单的生产-消费模式执行流程:（1）flg=false：

发错了，不好意思。重发！
LZ的单对单的生产-消费模式执行流程:
（1）flg=false： 消费者(out)等待,锁对象的wait方法释放锁；
（2） 生产者获得锁，生产产品(set)后，产品“入库”（flg=true）,然后唤醒消费者，这时下次即使生产者再次获得了锁，由于“仓库已满”，生产者依然会等待，直到消费者取走产品；
（3）消费者获得锁，消费产品(out)后，仓库空了（flg=false）,然后唤醒消生产者，与(2)类似，消费者下次即使再次获得了锁，由于“仓库已空”消费者依然会等待，直到生产者取生产完产品；
notify和wait读会释放锁，wait释放锁后会等待，直到其他持有同样锁的线程执行notify（或者notifyAll）方法。线程执行唤醒方法后，仍可以继续竞争锁。希望你能明白，另外你继续尝试多对多的生产消费模式，这里set out方法里面用if语句是会有问题的。希望这个解释能对你有帮助哈！

kaka小明 发表于 2013-6-7 14:12
发错了，不好意思。重发！
LZ的单对单的生产-消费模式执行流程:
（1）flg=false： 消费者(out)等待,锁对象 ...

明白了，多谢。就是wait(),sleep(),这些线程冻结状态时就会释放锁。我理解对吧？

sleep不释放锁！

kaka小明 发表于 2013-6-7 15:37
sleep不释放锁！

哦，谢谢