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

复制代码

这是代码，毕老师day12的示例代码。问题：

1. mike....man
   
2. Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
   
3.         at java.lang.Object.notify(Native Method)
   
4.         at cn.itheima.day11.Input.run(线程间通信.java:35)
   
5.         at java.lang.Thread.run(Thread.java:745)
   
6. Exception in thread "Thread-1" java.lang.IllegalMonitorStateException
   
7.         at java.lang.Object.notify(Native Method)
   
8.         at cn.itheima.day11.Output.run(线程间通信.java:60)
   
9.         at java.lang.Thread.run(Thread.java:745)

复制代码

求解释

你两个线程中的wait()方法与notify()方法均未加上调用的对象，就默认是线程自身的wait()方法与notify()，即Input与Output类自身的wait()方法与notify()。这样两个的线程的锁是不一样的。我们要实现同步，锁要求一样，将线程中的这四句代码分别改为： r.wait()与r.notify()。

notify方法，唤醒wait了的方法，那么多的线程，你要唤醒哪一个，唤醒拥有相同的锁在线程池中等待的第一个线程因此，上面的程序应该在wait时应该写成r.wait(); notify写为r.notify();，线程同步的前提，锁相同，操作的数据相同
修改后程序结果如此：

方法的调用需要对象,控制台报错的那几行代码,直接就一个裸体的方法,没有用对象去调用