wait()和notify()

wait()和notify()
notify()唤醒在此对象监视器上等待的单线程。
notifyAll()唤醒在此对象监视器上等待的所有线程。
wait()导致当前的线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法
wait(long timeout)导致当前的线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法，或者指定的时间过

完。
wait(long timeout,int nanos)导致当前的线程等待，直到其他线程调用此对象的notify()方法或者其他线程打断了当前线

程，或者指定的时间过完。
wait(),notify(),notifyAll()都不属于Thread类，而是属于Object基础类，也就是每个对象都有wait(),notify

(),notifyAll()的功能，因为每个对象都有锁，锁是每个对象的基础，当然操作锁的方法也是最基础了。
当需要调用以上的方法的时候，一定要对竞争资源进行加锁，如果不加锁的=话，则会报IllegalMonitorStateException异常
当想要调用wait()进行线程等待时，必须要取得这个锁对象的控制权（对象监视器），一般是放到synchronized(obj)代码中

在while循环里而不是if语句下使用wait,这样会在线程暂停恢复后都检查wait的条件，并在条件实际上并未改变的情况下处

理唤醒通知。
调用obj.wait()释放了obj的锁，否则其他线程也无法获得obj的锁，也就无法在synchronized(obj){obj.notify()}代码段内

唤醒A
notify()方法只会通知等待队列中的第一个相关线程（不会通知优先级比较高的线程）
notifyAll()通知所有等待该竞争资源的线程（也不会按照线程的优先级来执行）
假设有三个线程执行了obj.wait(),那么obj.notifyAll()则能全部唤醒thread1,thread2,thread3，但是要继续执行

obj.wait()的下一条语句，必须获得obj锁吗，因此，thread1,thread2,thread3只有一个有机会获得锁继续执行，例如

thread1,其余的需要等待thread1释放obj锁之后才能继续执行。
当调用obj.notify/notifyAll后，调用线程依旧持有obj锁，因此，thread1,thread2,thread3虽被唤醒，但是仍无法获得obj

锁。直到调用线程退出synchronized块、释放obj锁后，thread1,thread2,thread3中的一个才有机会获得锁继续执行

public class WaitNotifyTest {

/**
 * @param args
 */
//在多线程间共享的对象上使用wait
private String[] shareObj = {"true"};
public static void main(String[] args) {
	// TODO Auto-generated method stub

	WaitNotifyTest test = new WaitNotifyTest();
	ThreadWait threadWait1 = test.new ThreadWait("wait thread1");
	threadWait1.setPriority(2);
	ThreadWait threadWait2 = test.new ThreadWait("wait thread2");
	threadWait2.setPriority(3);
	ThreadWait threadWait3 = test.new ThreadWait("wait thread3");
	threadWait3.setPriority(4);
	ThreadNotify threadNotify = test.new ThreadNotify("notify thread");
	
	threadNotify.start();
	threadWait3.start();
	threadWait2.start();
	threadWait1.start();
}

class ThreadWait extends Thread{
	
	public ThreadWait(String name){
		super(name);
	}
	
	public void run(){
		
		synchronized(shareObj){
			while("true".equals(shareObj[0])){
				System.out.println("线程"+this.getName()+"开始等待");
				long startTime = System.currentTimeMillis();
				try {
					shareObj.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
				long endTime = System.currentTimeMillis();
				System.out.println("线程"+this.getName()+"等待时间为："+(endTime-startTime));
			}
		}
		System.out.println("线程"+getName()+"等待结束");
	}
}


class ThreadNotify extends Thread{
	public ThreadNotify(String name){
		
		super(name);
	}
	
	public void run(){
		
		try {
			sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		synchronized(shareObj){
			
			System.out.println("线程"+this.getName()+"开始准备通知");
			shareObj[0]="false";
			shareObj.notifyAll();
			System.out.println("线程"+this.getName()+"通知结束");
		}
		
		System.out.println("线程"+this.getName()+"运行结束");
	}
}

}