毕老师第12天03视频 等待唤醒机制为啥要把flag定义在Res类中,定义在其他地方不行吗?

1. class Res {
   
2.         String name;
   
3.         String sex;
   
4.         boolean flag = false;
   
5. }
   
6. 
   
7. class Input implements Runnable {
   
8. 
   
9.         private Res r;
   
10. 
    
11.         Input(Res r) {
    
12. 
    
13.                 this.r = r;
    
14.         }
    
15. 
    
16.         public void run() {
    
17.                 int x = 0;
    
18.                 while (true) {
    
19. 
    
20.                         synchronized (r) {
    
21. 
    
22.                                 if (r.flag)
    
23.                                         try {
    
24.                                                 r.wait();
    
25.                                         } catch (InterruptedException e) {
    
26.                                                 // TODO Auto-generated catch block
    
27.                                                 e.printStackTrace();
    
28.                                         }
    
29.                                 if (x == 0) {
    
30. 
    
31.                                         r.name = "mike";
    
32.                                         r.sex = "man";
    
33.                                 } else {
    
34.                                         r.name = "丽丽";
    
35.                                         r.sex = "女女女女女";
    
36.                                 }
    
37.                                 x = (x + 1) % 2;
    
38.                                 r.flag = true;
    
39.                                 r.notify();
    
40.                         }
    
41.                 }
    
42.         }
    
43. }
    
44. 
    
45. class Output implements Runnable {
    
46. 
    
47.         private Res r;
    
48. 
    
49.         Output(Res r) {
    
50. 
    
51.                 this.r = r;
    
52.         }
    
53. 
    
54.         public void run() {
    
55. 
    
56.                 while (true) {
    
57. 
    
58.                         synchronized (r) {
    
59. 
    
60.                                 if (!r.flag)
    
61.                                         try {
    
62.                                                 r.wait();
    
63.                                         } catch (InterruptedException e) {
    
64.                                                 // TODO Auto-generated catch block
    
65.                                                 e.printStackTrace();
    
66.                                         }
    
67.                                 System.out.println(r.name + "..." + r.sex);
    
68.                                 r.flag = false;
    
69.                                 r.notify();
    
70.                         }
    
71.                 }
    
72.         }
    
73. }
    
74. 
    
75. public class InputOutputDemo {
    
76. 
    
77.         public static void main(String[] args) {
    
78. 
    
79.                 Res r = new Res();
    
80. 
    
81.                 Input in = new Input(r);
    
82.                 Output out = new Output(r);
    
83. 
    
84.                 Thread t1 = new Thread(in);
    
85.                 Thread t2 = new Thread(out);
    
86. 
    
87.                 t1.start();
    
88.                 t2.start();
    
89.         }
    
90. 
    
91. }
    

复制代码

因为这个程序需要交替执行，执行一个input就要执行一个output，把flag定义在res中可以实现共享，也就是Input和Output公用一个flag，
当一个程序执行时，另一个程序等待。
放在其他类中就无法实现flag共享，也就无法控制input和output交替执行。

寇弘禄 发表于 2013-3-1 18:13
因为这个程序需要交替执行，执行一个input就要执行一个output，把flag定义在res中可以实现共享，也就是Inpu ...

根据你的回答从网上搜到的下面这句话
既然两个类都需要用这个属性，可以将这些字段提取到基类的字段，只要初始化一边，以后所有子类都可以使用

基类就是父类，一个类的子类会继承其父类的所有非私有方法和属性，但是不能为了用到某个类的一个属性或方法就去继承这个类，
比如人需要用到猫叫这个方法，但是人不能继承猫，只需要找到一个猫再用他的猫叫方法。
这个程序中如果下面两个类都继承了Res这个类，那么它们俩确实都具有了flag这个属性，但是它们俩用的不是同一个，而是各自类中都有一个，
就比如Person中都有name属性，并在Person中初始化为“张三”，Student继承Person，Student就有了name这个属性，但是在一个Student中的name属性值
可能更改为“李四”，而另一个Student的name属性值可能改为“王五”。
在这个程序中，它们两个中的flag属性都初始化为false，当执行到38行和68行的时候，input中的flag变为true，output中的变为false，而且始终保持不
变了，当两个线程都再次循环到if语句时，两个线程都等待了，程序就死锁了。