线程间通讯(等待唤醒机制)

锁.whit(); //将线程丢进线程池，暂停运行。
锁.notify(); //唤醒线程池中的最先存入那个同锁线程
锁.notifyAll(); //唤醒线程池中所有的同锁线程

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

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

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

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

class Res{
    String name;
    String sex;
    boolean flag=false;
}
class Input implements Runnable{
    private Res r;
    Input(Res r){
        this.r=r;
    }
    public void run(){
        int x=0;
        while(true){
            synchronized(r){
                if(r.flag){
                    try{
                        r.wait();
                    }
                    catch(Exception e){}
                }
                if(x==0){
                    r.name="丽丽";
                    r.sex="女";
                }else{
                    r.name="lisi";
                    r.sex="nan";
                }
                x=(x+1)%2;
                r.flag=true;
                r.notify();
            }
        }
    }
}
class Output implements Runnable{
    private Res r;
    Output(Res r){
        this.r=r;
    }
    public void run(){
        while(true){
            synchronized(r){
                if(!r.flag){
                    try{
                        r.wait();
                    }
                    catch(Exception e){}
                }
                System.out.println(r.name+"...."+r.sex);
                r.flag=false;
                r.notify();
            }
        }
    }
}
class Test{
    public static void main(String[] args){
        Res r=new Res();
        Input a=new Input(r);
        Output b=new Output(r);
        Thread t1=new Thread(a);
        Thread t2=new Thread(b);
        t1.start();
        t2.start();
    }
}