1. /**
   
2. 等待唤醒机制
   
3. wait();线程等待
   
4. notify();唤醒其他线程
   
5. notifyAll();唤醒全部线程
   
6. 
   
7. 都使用在同步中，因为要对持有监视器（锁）的线程操作，所以要用在同步中，只有同步才有锁。
   
8. 
   
9. 因为这些方法在操作同步线程时，都必须要标识它们所操作的线程共有的锁，只有同一锁上的被等待线程，可以被同一个锁上notify唤醒。不同锁的线程不能进行唤醒。就是只能于相同锁上才有效。
   
10. 锁可以是任意对象，因此能被任意对象调用的方法只能定义在Object类中。
    
11. 
    
12. 线程间通讯
    
13. 多个线程操作同一个资源，操作动作不同（输入输出）。
    
14. 
    
15. */
    
16. class Res//要共用的资源
    
17. {
    
18.         String name;
    
19.         String sex;
    
20.         boolean flag = false;//用来改变线程状态
    
21. }
    
22. //输入操作线程
    
23. class Input implements Runnable
    
24. {
    
25.         private Res r;
    
26.         Input(Res r)
    
27.         {
    
28.                 this.r = r;
    
29.         }
    
30.         public void run()
    
31.         {
    
32.                 int x = 0;//定义输入值
    
33.                 while(true)
    
34.                 {
    
35.                         synchronized(r)//使用唯一对象r使锁唯一
    
36.                         {
    
37.                                 
    
38.                                 if(r.flag)
    
39.                                         try{r.wait();}catch(Exception e){}//wait()有异常，实现接口中只能try
    
40.                                 if(x==0)
    
41.                                 {
    
42.                                         r.name="mini";
    
43.                                         r.sex="man";
    
44.                                 }
    
45.                                 else
    
46.                                 {
    
47.                                         r.name="五一";
    
48.                                         r.sex="女";
    
49.                                 }
    
50.                                 x = (x+1)%2;
    
51.                                 r.flag = true;//改变线程状态
    
52.                                 notify();//唤醒线程
    
53.                                 
    
54.                         }
    
55. 
    
56.                 }
    
57. 
    
58. 
    
59.         }
    
60. }
    
61. //输出操作线程
    
62. class Output implements Runnable
    
63. {
    
64.         private Res r;
    
65.         Output(Res r)
    
66.         {
    
67.                 this.r = r;
    
68.         }
    
69.         public void run()
    
70.         {
    
71.                 while(true)
    
72.                 {
    
73.                         synchronized(r)
    
74.                         {
    
75.                                 if(!r.flag)
    
76.                                         try{r.wait();}catch(Exception e){}//wait()有异常，实现接口中只能try
    
77.                                 System.out.println(r.name+"---"+r.sex);
    
78.                                 r.flag = false;//改变线程状态
    
79.                                 notify();//唤醒线程
    
80.                         }
    
81.                 }
    
82.         }
    
83. }
    
84. 
    
85. class InputOutputDemo
    
86. {
    
87.         public static void main(String[] args)
    
88.         {
    
89.                 //建立共用操作对象
    
90.                 Res r = new Res();
    
91.                 //建立输入输出操作动作对象
    
92.                 Input in = new Input(r);
    
93.                 Output out = new Output(r);
    
94.                 //建立输入输出操作线程
    
95.                 Thread t1 = new Thread(in);
    
96.                 Thread t2 = new Thread(out);
    
97.                 //开启输入输出线程，开始运行
    
98.                 t1.start();
    
99.                 t2.start();
    
100.         }
     
101. }
     
102. /*
     
103. F:\JAVA学习\java学习文档>java InputOutputDemo
     
104. Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
     
105.         at java.lang.Object.notify(Native Method)
     
106.         at Input.run(InputOutputDemo.java:56)
     
107.         at java.lang.Thread.run(Thread.java:722)
     
108. mini---man
     
109. Exception in thread "Thread-1" java.lang.IllegalMonitorStateException
     
110.         at java.lang.Object.notify(Native Method)
     
111.         at Output.run(InputOutputDemo.java:87)
     
112.         at java.lang.Thread.run(Thread.java:722)
     
113. */

复制代码

不懂是什么，编译过了，运行就挂了

你代码写错了，你把notify();改成r.notify();就可以运行了，因为你使用的锁是r所以唤醒的也用r

群里人说了，52和79的没有具体调用对象，应该是r.notify();

真的是不小心啊，还几天没有明白