java多线程等待唤醒机制

/**
 * 作者：kuma
 * 版本：v1.0
 * */
public class study_12_1
{
    public static void main(String[] args)
    {
        //线程间通信，比如一个线程存数据，另一个线程取数据
        //其实就是多个线程在操作同一个资源，但是操作的动作不同

        res r=new res();
        /*input in=new input(r);
        output out=new output(r);

        Thread t1=new Thread(in);
        Thread t2=new Thread(out);

        t1.start();
        t2.start();*/

        new Thread(new input(r)).start();
        new Thread(new output(r)).start();

    }
}

class res
{
    private String name;
    private String sex;
    private boolean f=false;
    public synchronized void set(String name,String sex)
    {
        if(f)
            try{this.wait();}catch(Exception e){}
        this.name=name;
        this.sex=sex;
        f=true;
        this.notify();
    }

    public synchronized void out()
    {
        if(!f)
            try{this.wait();}catch(Exception e){}
        System.out.println(name+"----"+sex);
        f=false;
        this.notify();
    }
}

class input implements Runnable
{
    Object obj=new Object();
    private res r;
    input(res r)
    {
        this.r=r;
    }
    public void run()
    {
        int flag=0;
        while(true)
        {
            synchronized (r)
            {
                if (flag == 0)
                {
                    r.set("mike","man");
                } else {
                    r.set("丽丽","女");
                }
                flag = (flag + 1) % 2;
            }
        }
    }
}

class output implements Runnable
{
    private res r;
    Object obj=new Object();
    output(res r)
    {
        this.r=r;
    }
    public void run()
    {
       while(true)
       {
           r.out();
       }
    }
}


/*
* wait();
* notify();
* notifyAll();
*  都是用在同步中，因为要对持有监视器的线程操作
* 所以要使用在同步中，因为只有同步才具有锁
*
* 为什么这些操作线程的方法要定义在Object类中呢？
* 因为这些方法在操作同步中线程时，都必须要标识他们所操作线程只有的锁
* 不可以对不同锁中的线程进行唤醒，
* 也就是说，等待和唤醒必须是同一个锁。
* */