/*
* 线程间通讯
* 多个线程同时操作同一个资源
*
* wait
* notify
* notifyAll
*
* 都使用在同步中，因为要对持有监视器(锁)的线程操作
* 所以要使用在同步中，因为只有同步才具有锁
*
* 为什么这些操作线程的方法要定义在Object类中呢？
* 因为这些方法操作同步线程时，都必须要标识它们所操作线程只有的锁，
* 只有同一个锁上的被等待线程才可以被同一个锁上notify唤醒
* 不可以对不同锁中的线程进行唤醒
*
* 也就是说，等待和唤醒必须是同一个锁
*
* 而锁可以是任意对象，所以可以被任意对象调用的的方法定义Object类中
*
*
* 优化后的代码
* */

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

复制代码

代码最好有注释

嗯，楼上的说的是，没注释很头痛

编写习惯很重要 最好开头能多行注释写下你的思路 然后编程的时候记得写注释 好习惯从开始养成~

没有注释的代码就像没有颜色的绘画