线程通信(wait,notify,notifyAll)

通信-对象的等待集wait set

1.wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此
对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)
2.notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的
线程。
3.wait(long timeout)让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的notify()方法或 notifyAll() 方法，
或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。

wait()方法

其实wait()方法就是使线程停止运行。

1. 方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法是用来将当前线程
   置入“预执行队列”中，并且在wait()所在的代码处停止执行，直到接到通知或被中断为止。
2. wait()方法只能在同步方法中或同步块中调用。如果调用wait()时，没有持有适当的锁，会抛出异常。
3. wait()方法执行后，当前线程释放锁，线程与其它线程竞争重新获取锁。
   范例：观察wait()方法使用

public static void main(String[] args) throws InterruptedException {
	Object object = new Object();
	synchronized (object) {
		System.out.println("等待中...");
		object.wait();
		System.out.println("等待已过...");
	} 
	System.out.println("main方法结束...");
}

这样在执行到object.wait()之后就一直等待下去，那么程序肯定不能一直这么等待下去了。这个时候就需要使用到了
另外一个方法唤醒的方法notify()。

notify()方法

notify方法就是使停止的线程继续运行。

1. 方法notify()也要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对
   其发出通知notify，并使它们重新获取该对象的对象锁。如果有多个线程等待，则有线程规划器随机挑选出一个
   呈wait状态的线程。
2. 在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出
   同步代码块之后才会释放对象锁。
   范例：使用notify()方法唤醒线程

package bit.java.thread;
class MyThread implements Runnable {
	private boolean flag;
	private Object obj;
	public MyThread(boolean flag, Object obj) {
		super();
		this.flag = flag;
		this.obj = obj;
	} 
	public void waitMethod() {
		synchronized (obj) {
			try {
				while (true) {
				System.out.println("wait()方法开始.. " +
				Thread.currentThread().getName());
				obj.wait();
				System.out.println("wait()方法结束.. " +
				Thread.currentThread().getName());
				return;
			}
		} catch (Exception e) {
			e.printStackTrace();
			}
		}
	} 
public void notifyMethod() {
	synchronized (obj) {
		try {
			System.out.println("notify()方法开始.. "
			+Thread.currentThread().getName());
		obj.notify();
		System.out.println("notify()方法结束.. " + 					Thread.currentThread().getName());
		} catch (Exception e) {
		e.printStackTrace();
		}
	}
} 
@Override
	public void run() {
		if (flag) {
		this.waitMethod();
		} else {
		this.notifyMethod();
	}
}
}
public class TestThread {
public static void main(String[] args) throws InterruptedException {
		Object object = new Object();
	MyThread waitThread = new MyThread(true, object);
	MyThread notifyThread = new MyThread(false, object);
	Thread thread1 = new Thread(waitThread, "wait线程");
	Thread thread2 = new Thread(notifyThread, "notify线程");
	thread1.start();
	Thread.sleep(1000);
	thread2.start();
	System.out.println("main方法结束!!");
}
}

从结果上来看第一个线程执行的是一个waitMethod方法，该方法里面有个死循环并且使用了wait方法进入等待状态
将释放锁，如果这个线程不被唤醒的话将会一直等待下去，这个时候第二个线程执行的是notifyMethod方法，该方
法里面执行了一个唤醒线程的操作，并且一直将notify的同步代码块执行完毕之后才会释放锁然后继续执行wait结束
打印语句。
注意：wait，notify必须使用在synchronized同步方法或者代码块内

notifyAll()方法

以上讲解了notify方法只是唤醒某一个等待线程，那么如果有多个线程都在等待中怎么办呢，这个时候就可以使用
notifyAll方法可以一次唤醒所有的等待线程

wait 和 sleep 的对比

其实理论上 wait 和 sleep 完全是没有可比性的，因为一个是用于线程之间的通信的，一个是让线程阻塞一段时间，
唯一的相同点就是都可以让线程放弃执行一段时间。用生活中的例子说的话就是婚礼时会吃糖，和家里自己吃糖之间有差别。说白了放弃线程执行只是 wait 的一小段现象。
当然为了面试的目的，我们还是总结下：

1. wait 之前需要请求锁，而wait执行时会先释放锁，等被唤醒时再重新请求锁。这个锁是 wait 对像上的 monitorlock
2. sleep 是无视锁的存在的，即之前请求的锁不会释放，没有锁也不会请求。
3. wait 是 Object 的方法
4. sleep 是 Thread 的静态方法