1，普通版
/*
        线程间通信
        其实就是多个线程在操作同一个资源
        只是操作的动作不同
        
        
        
wait();
notify();
notifyAll();

都是用在同步中，因为要对持有监视器（锁）的线程操作。
所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程持有的锁
只有同一个锁上的被等待线程。可以被同一个锁上的notify唤醒
不可以对不同锁中的线程进行唤醒。

也就是说。等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object类中
        
*/

1. //定义一个资源类
   
2. class Person {
   
3.         String name;
   
4.         String sex;
   
5.         boolean b = false; //定义一个标记
   
6. }
   
7. 
   
8. //定义一个输入类
   
9. class Input implements Runnable {
   
10.         
    
11.         private Person p; //定义一个资源类的对象
    
12.         Input(Person p) {
    
13.                         this.p = p;
    
14.         }
    
15.         
    
16.         //建立run方法
    
17.         public void run() {
    
18.                 int x = 0;
    
19.                 while(true) {
    
20.                         synchronized(p) { //因为线程出现安全隐患问题。所以加上同步
    
21.                                 if(p.b)
    
22.                                         //假如标记为真。就wait();进入等待状态
    
23.                                         try {p.wait();} catch(InterruptedException e) {}
    
24.                                 if(x == 0) {
    
25.                                         p.name = "shasha";
    
26.                                         p.sex = "girl";
    
27.                                 } else {
    
28.                                         p.name = "志志";
    
29.                                         p.sex = "男";
    
30.                                 }
    
31.                                 x = (x + 1) % 2;
    
32.                                 p.b = true; //把标记改为真。
    
33.                                 p.notify(); //唤醒等待的程序
    
34.                         }
    
35.                 }
    
36.         }
    
37.         
    
38. }
    
39. 
    
40. //定义一个输出类
    
41. class Output implements Runnable {
    
42.         
    
43.         private Person p;
    
44.         Output(Person p) {
    
45.                 this.p = p;
    
46.         }
    
47.         
    
48.         public void run() {
    
49.                 while(true) {
    
50.                         synchronized(p) { //因为对象p是唯一的。所以把p定义为同步锁
    
51.                                 if(!p.b)
    
52.                                         try {p.wait();} catch(InterruptedException e) {}
    
53.                                 System.out.println(p.name + "run ...." + p.sex);
    
54.                                 p.b = false; //把标记改为假
    
55.                                 p.notify(); //唤醒等待的线程
    
56.                         }
    
57.                 }
    
58.         }
    
59.         
    
60. }
    
61. 
    
62. //定义一个调试类
    
63. class InputOutputDemo {
    
64.         public static void main(String[] args) {
    
65.                 Person p = new Person(); //建立资源类
    
66.                 Input in = new Input(p); //把资源类对象当做实参传递给输入类的构造函数
    
67.                 Output ou = new Output(p); //把资源类对象当做实参传递给输出类的构造函数
    
68.                 Thread t1 = new Thread(in);
    
69.                 Thread t2 = new Thread(ou);
    
70.                 t1.start();
    
71.                 t2.start();
    
72.         }
    
73. }
    
74. 
    
75. 
    
76. 
    
77. 
    
78. 2，优化后的代码（优化版）
    
79. //定义一个资源类
    
80. class Person1 {
    
81.         private String name;
    
82.         private String sex;
    
83.         boolean b = false; //定义一个标记
    
84.         //在资源类中定义一个赋值函数，但是有可能在赋值的时候出现问题。所以使用同步，变成同步函数
    
85.         public synchronized void set(String name, String sex) {
    
86.                 if(b)
    
87.                         //假如标记为真。就wait();进入等待状态
    
88.                         try {this.wait();} catch(InterruptedException e) {}
    
89.                 this.name = name;
    
90.                 this.sex = sex;
    
91.                 this.b = true;
    
92.                 this.notify();
    
93.         }
    
94.         
    
95.         public synchronized void out() {
    
96.                 if(!b)
    
97.                         try {this.wait();} catch(InterruptedException e) {}
    
98.                 System.out.println(name + "run......" + sex);
    
99.                 this.b = false;
    
100.                 this.notify();
     
101.         }
     
102.         
     
103. }
     
104. 
     
105. //定义一个输入类
     
106. class Input1 implements Runnable {
     
107.         
     
108.         private Person1 p; //定义一个资源类的对象
     
109.         Input1(Person1 p) {
     
110.                         this.p = p;
     
111.         }
     
112.         
     
113.         //建立run方法
     
114.         public void run() {
     
115.                 int x = 0;
     
116.                 while(true) {
     
117.                         if(x == 0) {
     
118.                                 p.set("meimei", "girl");
     
119.                         } else {
     
120.                                 p.set("志志", "男");
     
121.                         }
     
122.                         x = (x + 1) % 2;
     
123.                 }
     
124.         }
     
125.         
     
126. }
     
127. 
     
128. //定义一个输出类
     
129. class Output1 implements Runnable {
     
130.         
     
131.         private Person1 p;
     
132.         Output1(Person1 p) {
     
133.                 this.p = p;
     
134.         }
     
135.         
     
136.         public void run() {
     
137.                 while(true) {
     
138.                         p.out();
     
139.                 }
     
140.         }
     
141.         
     
142. }
     
143. 
     
144. //定义一个调试类
     
145. class InputOutputDemo1 {
     
146.         public static void main(String[] args) {
     
147.                 Person1 p = new Person1();
     
148.                 new Thread(new Input1(p)).start();
     
149.                 new Thread(new Output1(p)).start();
     
150.         }
     
151. }

复制代码

1，普通版
/*
        线程间通信
        其实就是多个线程在操作同一个资源
        只是操作的动作不同
        
        
        
wait();
notify();
notifyAll();

都是用在同步中，因为要对持有监视器（锁）的线程操作。
所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程持有的锁
只有同一个锁上的被等待线程。可以被同一个锁上的notify唤醒
不可以对不同锁中的线程进行唤醒。

也就是说。等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object类中
        
*/

1. //定义一个资源类
   
2. class Person {
   
3.         String name;
   
4.         String sex;
   
5.         boolean b = false; //定义一个标记
   
6. }
   
7. 
   
8. //定义一个输入类
   
9. class Input implements Runnable {
   
10.         
    
11.         private Person p; //定义一个资源类的对象
    
12.         Input(Person p) {
    
13.                         this.p = p;
    
14.         }
    
15.         
    
16.         //建立run方法
    
17.         public void run() {
    
18.                 int x = 0;
    
19.                 while(true) {
    
20.                         synchronized(p) { //因为线程出现安全隐患问题。所以加上同步
    
21.                                 if(p.b)
    
22.                                         //假如标记为真。就wait();进入等待状态
    
23.                                         try {p.wait();} catch(InterruptedException e) {}
    
24.                                 if(x == 0) {
    
25.                                         p.name = "shasha";
    
26.                                         p.sex = "girl";
    
27.                                 } else {
    
28.                                         p.name = "志志";
    
29.                                         p.sex = "男";
    
30.                                 }
    
31.                                 x = (x + 1) % 2;
    
32.                                 p.b = true; //把标记改为真。
    
33.                                 p.notify(); //唤醒等待的程序
    
34.                         }
    
35.                 }
    
36.         }
    
37.         
    
38. }
    
39. 
    
40. //定义一个输出类
    
41. class Output implements Runnable {
    
42.         
    
43.         private Person p;
    
44.         Output(Person p) {
    
45.                 this.p = p;
    
46.         }
    
47.         
    
48.         public void run() {
    
49.                 while(true) {
    
50.                         synchronized(p) { //因为对象p是唯一的。所以把p定义为同步锁
    
51.                                 if(!p.b)
    
52.                                         try {p.wait();} catch(InterruptedException e) {}
    
53.                                 System.out.println(p.name + "run ...." + p.sex);
    
54.                                 p.b = false; //把标记改为假
    
55.                                 p.notify(); //唤醒等待的线程
    
56.                         }
    
57.                 }
    
58.         }
    
59.         
    
60. }
    
61. 
    
62. //定义一个调试类
    
63. class InputOutputDemo {
    
64.         public static void main(String[] args) {
    
65.                 Person p = new Person(); //建立资源类
    
66.                 Input in = new Input(p); //把资源类对象当做实参传递给输入类的构造函数
    
67.                 Output ou = new Output(p); //把资源类对象当做实参传递给输出类的构造函数
    
68.                 Thread t1 = new Thread(in);
    
69.                 Thread t2 = new Thread(ou);
    
70.                 t1.start();
    
71.                 t2.start();
    
72.         }
    
73. }
    
74. 
    
75. 
    
76. 
    
77. 
    
78. 2，优化后的代码（优化版）
    
79. //定义一个资源类
    
80. class Person1 {
    
81.         private String name;
    
82.         private String sex;
    
83.         boolean b = false; //定义一个标记
    
84.         //在资源类中定义一个赋值函数，但是有可能在赋值的时候出现问题。所以使用同步，变成同步函数
    
85.         public synchronized void set(String name, String sex) {
    
86.                 if(b)
    
87.                         //假如标记为真。就wait();进入等待状态
    
88.                         try {this.wait();} catch(InterruptedException e) {}
    
89.                 this.name = name;
    
90.                 this.sex = sex;
    
91.                 this.b = true;
    
92.                 this.notify();
    
93.         }
    
94.         
    
95.         public synchronized void out() {
    
96.                 if(!b)
    
97.                         try {this.wait();} catch(InterruptedException e) {}
    
98.                 System.out.println(name + "run......" + sex);
    
99.                 this.b = false;
    
100.                 this.notify();
     
101.         }
     
102.         
     
103. }
     
104. 
     
105. //定义一个输入类
     
106. class Input1 implements Runnable {
     
107.         
     
108.         private Person1 p; //定义一个资源类的对象
     
109.         Input1(Person1 p) {
     
110.                         this.p = p;
     
111.         }
     
112.         
     
113.         //建立run方法
     
114.         public void run() {
     
115.                 int x = 0;
     
116.                 while(true) {
     
117.                         if(x == 0) {
     
118.                                 p.set("meimei", "girl");
     
119.                         } else {
     
120.                                 p.set("志志", "男");
     
121.                         }
     
122.                         x = (x + 1) % 2;
     
123.                 }
     
124.         }
     
125.         
     
126. }
     
127. 
     
128. //定义一个输出类
     
129. class Output1 implements Runnable {
     
130.         
     
131.         private Person1 p;
     
132.         Output1(Person1 p) {
     
133.                 this.p = p;
     
134.         }
     
135.         
     
136.         public void run() {
     
137.                 while(true) {
     
138.                         p.out();
     
139.                 }
     
140.         }
     
141.         
     
142. }
     
143. 
     
144. //定义一个调试类
     
145. class InputOutputDemo1 {
     
146.         public static void main(String[] args) {
     
147.                 Person1 p = new Person1();
     
148.                 new Thread(new Input1(p)).start();
     
149.                 new Thread(new Output1(p)).start();
     
150.         }
     
151. }

复制代码