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

复制代码

1. wait(); 可以让当前线程处于等待，这时的线程被临时存储到了线程池中 ;
   
  2. notify();唤醒线程池中任意一个等待的线程。

  3.  notifyAll();唤醒线程池中所有的等待线程。

        这些方法在使用时，必须定义在同步中，必须被所属同步的锁调用。

      如果程序运行到wait();就会进入到线程池中，放弃了CUP的执行权，
当运行到notify();时，是从线程池中唤醒任意一个线程。

还有一点要注意，就是要声明异常；