1. class ThreadResource {
   
2.         public static void main(String[] args) {
   
3.                 Resource r = new Resource();
   
4.                 new Thread(new Input(r)).start();
   
5.                 new Thread(new Output(r)).start();
   
6.         }
   
7. }
   
8. 
   
9. 
   
10. class Input implements Runnable{
    
11.         private Resource r;
    
12.         Input(Resource r) {
    
13.                 this.r = r;
    
14.         }
    
15.         public void run() {
    
16.                 int x = 0;
    
17.                 while(true) {
    
18.                         synchronized(r) {
    
19.                                 if(r.flag)                // Res类里面flag已经定义为false，if(r.flag)里面的flag不也是false吗？
    
20.                                                                 //那么在Input'线程第一次运行时，就应该等待，赋值操作也不会运行。
    
21.                                                                 //老师说，flag第一次已经为false，所以就不需要等待，直接赋值。
    
22.                                                                 //感觉这里好矛盾啊，实在搞不懂了,看了几片帖子都没有解释清楚。
    
23.                                                                 //希望高手详细指点下flag的问题，多谢
    
24.                                                 
    
25.                                         try{r.wait();}catch(Exception e){}
    
26.                                 if(x == 0) {
    
27.                                         r.name = "Mike";
    
28.                                         r.sex = "man";
    
29.                                 } else {
    
30.                                         r.name = "Lily";
    
31.                                         r.sex = "woman";
    
32.                                 }
    
33.                                 x = (x + 1) % 2;
    
34.                                 r.flag = true;
    
35.                                 r.notify();
    
36.                         }
    
37.                 }
    
38.         }
    
39. }
    
40. 
    
41. class Output implements Runnable {
    
42.         private Resource r;
    
43.         Output(Resource r) {
    
44.                 this.r = r;
    
45.         }
    
46.         public void run() {
    
47.                 while(true) {
    
48.                         synchronized(r) {
    
49.                                 if(!r.flag)                        
    
50.                                         try{r.wait();}catch(Exception e){}
    
51.                                 System.out.println(r.name + ": " + r.sex);
    
52.                                 r.flag = false;
    
53.                                 r.notify();
    
54.                         }
    
55.                 }
    
56.         }
    
57. }
    
58. 
    
59. class Resource {
    
60.         String name;
    
61.         String sex;
    
62.         boolean flag = false;
    
63. }
    

复制代码

flag标记的作用其实也就是让线程有规律的执行代码，input这个类，如果它的标记为true时，就让线程挂起，这个线程挂起的时候，当然会去执行另一个线程了，另一个线程!true当然是false了，所以就不会在挂了，直接执行代码就OK，执行完，把标记改了，在把对方唤醒，也许自己还能抢到执行权，但这时标记已经改过了，回头判断标记的时，这时!false，结果当然是true，这时就必须挂起的，如此循环。

亲 你都说r.flage是false了 那if(r.flage)就是假，就直接跳过了呀，怎么会等待呢。你就理解成有没有就行。刚开始没有是false，写进去就有了true

哪颗最亮的星星 发表于 2013-7-20 18:05
flag标记的作用其实也就是让线程有规律的执行代码，input这个类，如果它的标记为true时，就让线程挂起，这 ...

那也就是说if(flag)这里flag的值，和boolean flag = false没有关系，Input线程第一次运行时可以直接忽略。直到flag = true后，Input线程在唤醒Output线程后还持有执行权，这时再去判断flag，指已经值已经为true，所以就等待？我就是这点很迷糊，既然定义了flag为false，那为什么if(flag)里面的flag为什么不是false

1. if(x == 0) {
   
2.                                         r.name = "Mike";
   
3.                                         r.sex = "man";
   
4.                                 } else {
   
5.                                         r.name = "Lily";
   
6.                                         r.sex = "woman";
   
7.                                 }
   
8. ///////////////////////
   
9. if(!r.flag)                        
   
10.                                         try{r.wait();}catch(Exception e){}

复制代码

1. if(x == 0) {
   
2.                                         r.name = "Mike";
   
3.                                         r.sex = "man";
   
4.                                 } else {
   
5.                                         r.name = "Lily";
   
6.                                         r.sex = "woman";
   
7.                                 }
   
8. ///////////////////////
   
9. if(!r.flag)                        
   
10.                                         try{r.wait();}catch(Exception e){}
    

复制代码

你说的没错，flag初始值是false，如果input抢到资源则执行////上面代码进行赋值，如果output抢到资源就会执行///下面代码，等待，output等待时会放弃执行资格并释放锁此时input就能来获得执行资格。所以无论那个线程抢到资源结果都是先赋值

为什么发帖总是丢数据呢？害我重敲一边

草貌路飞 发表于 2013-7-20 18:35
亲 你都说r.flage是false了 那if(r.flage)就是假，就直接跳过了呀，怎么会等待呢。你就理解成有没有就行。 ...

迷迷糊糊总算是懂了点，老师把我说晕菜了都，如果flag为false，r.flag就是false，也就是说满足了if(r.flag)的判断条件那么try{r.wait();}catch(Exception e){}作为它的执行体，就会被执行，Input线程一开始执行
就会等待。这么理解似乎也没有错啊。关键老师说false代表属性没有具体值，如果为false就要
进行赋值操作，赋值后改为true表示属性有值了。哎。。。我就崩溃了。你看看我这样改写的代码对不对

1. class ThreadResource {
   
2.         public static void main(String[] args) {
   
3.                 Resource r = new Resource();
   
4.                 new Thread(new Input(r)).start();
   
5.                 new Thread(new Output(r)).start();
   
6.         }
   
7. }
   
8. 
   
9. class Input implements Runnable{
   
10.         private Resource r;
    
11.         Input(Resource r) {
    
12.                 this.r = r;
    
13.         }
    
14.         public void run() {
    
15.                 int x = 0;
    
16.                 while(true) {
    
17.                         synchronized(r) {
    
18.                                 if(r.flag == true)        //满足条件表示属性有值，需要输出，输入线程等待
    
19.                                         try{r.wait();}catch(Exception e){}
    
20.                                 if(x == 0) {
    
21.                                         r.name = "Mike";
    
22.                                         r.sex = "man";
    
23.                                 } else {
    
24.                                         r.name = "Lily";
    
25.                                         r.sex = "woman";
    
26.                                 }
    
27.                                 x = (x + 1) % 2;
    
28.                                 r.flag = true;
    
29.                                 r.notify();
    
30.                         }
    
31.                 }
    
32.         }
    
33. }
    
34. 
    
35. class Output implements Runnable {
    
36.         private Resource r;
    
37.         Output(Resource r) {
    
38.                 this.r = r;
    
39.         }
    
40.         public void run() {
    
41.                 while(true) {
    
42.                         synchronized(r) {
    
43.                                 if(r.flag == false)        //满足条件表示属性没值，需要赋值，输出线程等待               
    
44.                                         try{r.wait();}catch(Exception e){}
    
45.                                 System.out.println(r.name + ": " + r.sex);
    
46.                                 r.flag = false;
    
47.                                 r.notify();
    
48.                         }
    
49.                 }
    
50.         }
    
51. }
    
52. 
    
53. class Resource {
    
54.         String name;
    
55.         String sex;
    
56.         boolean flag = false;
    
57. }

复制代码

罗广伟 发表于 2013-7-20 19:17
你说的没错，flag初始值是false，如果input抢到资源则执行////上面代码进行赋值，如果output抢到资源就会执 ...

多谢，现在已经明白了

崔龙飞 发表于 2013-7-20 20:24
迷迷糊糊总算是懂了点，老师把我说晕菜了都，如果flag为false，r.flag就是false，也就是说满足了if(r.fla ...

如果这样能便于你理解的话 是可以的