class Res {
	String name;
	String sex;
}

class Input implements Runnable {
	private Res r;

	public Input(Res r) {
		// TODO Auto-generated constructor stub
		this.r = r;
	}

	public void run() {
		int x = 0;
		while (true) {
			synchronized (r) {
				if (x == 0) {
					r.name = "mike";
					r.sex = "man";
				} else {
					r.name = "丽丽";
					r.sex = "女女女";
				}
				x = ++x % 2;
			}
		}
	}
}

class Output implements Runnable {
	private Res r;
	Object obj = new Object();

	Output(Res r) {
		this.r = r;
	}

	public void run() {
		while (true) {
			synchronized (r) {
				System.out.println(r.name + "----" + r.sex);
			}
		}
	}
}

public class Communicate {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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();

	}
}

这是上一篇文章多线程之间的通信的一个例子，但是这个例子的带引结果却是这样的：

丽丽----女女女

丽丽----女女女

丽丽----女女女

丽丽----女女女

丽丽----女女女

丽丽----女女女

丽丽----女女女

mike----man

mike----man

mike----man

mike----man

是这样的情况。先说说这种情况是怎么发生的：

这个例子中有两个线程，分别实现输入和输出的功能。某一时刻输入的线程得到了cpu执行权的时候，它会不停的输入，不停的更新Res中的内容，同样的，当输出的线程得到执行权的时候便会不停的打印当前Res的内容，所以便出现了这种情况。

现在我们想让他们交替的打印，也就是说是这样的：

丽丽----女女女

mike----man

丽丽----女女女

mike----man

丽丽----女女女

mike----man

这就用到了多线程的等待唤醒机制，所谓的等待唤醒机制其实就是wait()方法和notify() 方法，使当前线程等待从而放弃执行资格和唤醒线程。

-----------------API-------------------------

wait

public final void wait()
                throws InterruptedException

在其他线程调用此对象的 notify() 方法或notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行wait(0) 调用一样。

当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。

对于某一个参数的版本，实现中断和虚假唤醒是可能的，而且此方法应始终在循环中使用：

synchronized (obj) {
while (<condition does not hold>)
obj.wait();
... // Perform action appropriate to condition
     }
 

此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述，请参阅 notify 方法。

抛出：

IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。

InterruptedException - 如果在当前线程等待通知之前或者正在等待通知时，任何线程中断了当前线程。在抛出此异常时，当前线程的中断状态 被清除。

notify

public final void notify()

唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个wait 方法，在对象的监视器上等待。

直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。

此方法只应由作为此对象监视器的所有者的线程来调用。通过以下三种方法之一，线程可以成为此对象监视器的所有者：

• 通过执行此对象的同步实例方法。
• 通过执行在此对象上进行同步的 synchronized 语句的正文。
• 对于 Class 类型的对象，可以通过执行该类的同步静态方法。

一次只能有一个线程拥有对象的监视器。

抛出：

IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。

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

notify() 唤醒一个线程，一般是第一个被等待的线程。

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

class Input implements Runnable {
	private Res r;

	public Input(Res r) {
		// TODO Auto-generated constructor stub
		this.r = r;
	}

	public void run() {
		int x = 0;
		while (true) {
			synchronized (r) {
				if (r.flag == true)
					try {
						r.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				if (x == 0) {
					r.name = "mike";
					r.sex = "man";
				} else {
					r.name = "丽丽";
					r.sex = "女女女";
				}
				x = ++x % 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 == false)
					try {
						r.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				System.out.println(r.name + "----" + r.sex);
				r.flag = false;
				r.notify();

			}
		}
	}
}

public class Communicate {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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();

	}
}

/*

Wait（） notify() notifyAll ()

都使用在同步中，因为要对持有监视器（锁）的线程操作

所以要使用在同步中，因为只有同步才具有锁

为什么这些操作线程的方法要定义在Object类中呢？

因为这些方法在操作同步中线程时，都必须要标识他们所操作线程的只有锁

只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒，不可以对不同锁中的线程进行唤醒。

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

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

*/

Java---18---多线程：等待唤醒机制