day12/WaitNotifyThread.java

/*
等待唤醒机制。
r.wait()	//抛中断异常了，内部try
r.notify()
r是锁，等待唤醒必须是同一个锁。（两波小朋友玩抓人，而不是一波小朋友---经典）

-------------

此程序是对InputOutputDemo程序的优化，
因为通过打印InputOutputDemo结果发现，不是输入一个，输出一个，
而是一个线程有执行权后，输入n多次(后面输入的被前面覆盖了)，另一个线程有执行权后，输出同一个n多次。
现在通过等待唤醒机制来优化。
*/

class Resource
{
	String name;
	String sex;
	boolean flag=false;
}

class Input implements Runnable
{
	private Resource r;
	Input(Resource 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="mike";
					r.sex="man";
				}
				else
				{
					r.name="丽丽";
					r.sex="女女女女女";
				}
				x=(x+1)%2;
				r.flag=true;
				r.notify();
			}
		}
	}
}

class Output implements Runnable
{
	private Resource r;
	Output(Resource 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 WaitNotifyThread 
{
	public static void main(String[] args) 
	{
		Resource r = new Resource();

		Input in = new Input(r);
		Output out = new Output(r);

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

		t1.start();
		t2.start();
	}
}

/*
E:\javademo\day12>java WaitNotifyThread
mike...man
丽丽...女女女女女
mike...man
丽丽...女女女女女
mike...man
丽丽...女女女女女
mike...man
丽丽...女女女女女
mike...man
丽丽...女女女女女
mike...man
丽丽...女女女女女
*/




/*
wait()
notify()
notifyAll()

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

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

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

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