今天在复习多线程这块时发现了个小问题,是关于多线程间通信的。如下：

1. 
   
2. class Input implements Runnable
   
3. {
   
4.       Res r;
   
5.       Input(Res r)
   
6.      {
   
7.         this.r = r;
   
8.      }
   
9.         public void run()
   
10.       {
    
11.         int x = 0;
    
12.                while(true)
    
13.              {
    
14.                  synchronized(r)     //当input持有锁进入后，output 是不能够进入同步代码块的，当然我的假设               
    
15.                     {                       //是input先持有锁进来的output还没来的及判断锁更没有进入等待状态。
    
16.                         if(r.flag)              
    
17.                           try{r.wait();}catch(Exception e){}   //当input线程执行到这时，进入了等待状态后，它还持有锁啊，   
    
18.                       if(x==0)                                              //output线程为什么还能够执行？难道是input进入等待状态
    
19.                         {                                                       //后，不仅放弃了执行权，锁也不持有了吗  ？
    
20.                            r.name = "小明";                                 
    
21.                           r.sex = "男男男男男男";
    
22.                         }
    
23.                     else
    
24.                       {
    
25.                         r.name = "rose";
    
26.                        r.sex = "female";
    
27.                       }
    
28.                         x=(x+1)%2;
    
29.                        r.flag = true;
    
30.                        r.notify();   
    
31.                }
    
32. 
    
33.           }
    
34.      }
    
35. 
    
36. }
    
37. //////////////////////////////////////////////////////////////////////////////////////////////////
    
38. class Output implements Runnable
    
39. {
    
40.        Res r;
    
41.      Output(Res r)
    
42.      {
    
43.        this.r = r;
    
44.     }
    
45.        public void run()
    
46.        {
    
47.                 while(true)
    
48.                 {
    
49. 
    
50.                  synchronized(r)    //当input持有锁在执行的时候甚至进入等待状态后，output很可能还没有进入同步代码块啊
    
51.                       {
    
52.                             if(!r.flag)
    
53.                           try{r.wait();}catch(Exception e){}
    
54.                          System.out.println(r.name+"...."+r.sex);
    
55.                           r.flag = false ;
    
56.                          r.notify();
    
57.                   }
    
58. 
    
59.              }
    
60.       }
    
61. }

复制代码

我的问题都写在上面的注释里面了，谁来帮我把思路捋捋顺。

当多个线程使用同一个监视器时，如果某个线程先拿到监视器则其他线程无法进入同步代码块，但如果得到监视器的线程等待时即进入wait状态时不仅放弃了cpu执行权，同时还放弃了锁，这时其他线程就可以执行了，如果有个线程把wait的线程叫醒了的话它一旦获得cpu执行权就会开始执行，因为他已经进入同步代码块内部，不用再管锁在谁手里了。

1. class  Duo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Res r = new Res();
   
6.                 Thread t1 = new Thread(new Input(r));
   
7.                 Thread t2 = new Thread(new Output(r));
   
8.                 t1.start();
   
9.                 t2.start();
   
10.         }
    
11. }
    
12. 
    
13. class Res
    
14. {
    
15.         boolean flag = false;
    
16.         String name;
    
17.         String sex;
    
18. }
    
19. class Input implements Runnable
    
20. 
    
21. {
    
22. 
    
23.       Res r;
    
24. 
    
25.       Input(Res r)
    
26. 
    
27.      {
    
28. 
    
29.         this.r = r;
    
30. 
    
31.      }
    
32. 
    
33.         public void run()
    
34. 
    
35.       {
    
36.         int x = 0;
    
37. 
    
38.                while(true)
    
39. 
    
40.              {
    
41.                  synchronized(r)     //当input持有锁进入后，output 是不能够进入同步代码块的，当然我的假设               
    
42. 
    
43.                     {                       //是input先持有锁进来的output还没来的及判断锁更没有进入等待状态。
    
44. 
    
45.                         if(r.flag)              
    
46. 
    
47.                           try{r.wait();}catch(Exception e){}   //当input线程执行到这时，进入了等待状态后，它还持有锁啊，   
    
48. 
    
49.                       if(x==0)                                              //output线程为什么还能够执行？难道是input进入等待状态
    
50. 
    
51.                         {                                                       //后，不仅放弃了执行权，锁也不持有了吗  ？
    
52. 
    
53.                            r.name = "小明";                                 
    
54.                           r.sex = "男男男男男男";
    
55. 
    
56.                         }
    
57. 
    
58.                     else
    
59. 
    
60.                       {
    
61. 
    
62.                         r.name = "rose";
    
63. 
    
64.                        r.sex = "female";
    
65. 
    
66.                       }
    
67. 
    
68.                         x=(x+1)%2;
    
69. 
    
70.                        r.flag = true;
    
71. 
    
72.                        r.notify();   
    
73.                }
    
74. 
    
75. 
    
76.           }
    
77. 
    
78.      }
    
79. 
    
80. 
    
81. }
    
82. 
    
83. //////////////////////////////////////////////////////////////////////////////////////////////////
    
84. 
    
85. class Output implements Runnable
    
86. 
    
87. {
    
88. 
    
89.        Res r;
    
90. 
    
91.      Output(Res r)
    
92. 
    
93.      {
    
94. 
    
95.        this.r = r;
    
96. 
    
97.     }
    
98. 
    
99.        public void run()
    
100. 
     
101.        {
     
102.                 while(true)
     
103. 
     
104.                 {
     
105. 
     
106.                  synchronized(r)    //当input持有锁在执行的时候甚至进入等待状态后，output很可能还没有进入同步代码块啊
     
107. 
     
108.                       {
     
109. 
     
110.                             if(!r.flag)
     
111. 
     
112.                           try{r.wait();}catch(Exception e){}
     
113. 
     
114.                          System.out.println(r.name+"...."+r.sex);
     
115. 
     
116.                           r.flag = false ;
     
117. 
     
118.                          r.notify();
     
119. 
     
120.                   }
     
121. 
     
122. 
     
123.              }
     
124. 
     
125.       }
     
126. 
     
127. }

复制代码

好吧，楼主，我必须说如果按照我加上的代码的话应该没问题，但是如果你在主函数里面是这样写的话就有问题了

1. class  Duo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 //Res r = new Res();
   
6.                 Thread t1 = new Thread(new Input(new Res()));
   
7.                 Thread t2 = new Thread(new Output(new Res()));
   
8.                 t1.start();
   
9.                 t2.start();
   
10.         }
    
11. }
    

复制代码

如果是这样的话，两个线程根本不是用同样的锁，线程当然都可以各执行各的了!!楼主，是你调用的问题吧？