* notify notifyAll wait 使用 
 * 1 一个对象执行相应的方法
 *  （一个对象wait后，需要调用同一个对象的notify唤醒这个对象的wait，可以在不同线程执行）
 * 2 个人理解方法执行必须在synchronize代码块中执行（因为方法执行的时候必须获得对象监视器，个人理解监视器就是锁）
 * 3 执行wait后当前线程会释放掉这个对象的锁，则其他线程就会获得这个对象锁（其他线程就能执行synchronize代码块中代码）
 * 
 * 场景设想： 一个运输公司要运输一批货物
 *         领导告诉所有的搬运工时刻准备着，（主线程创建N个线程待用，所有线程处于等待转改）
 *         一旦运输货物到了， （资源转备好后）
 *         马上开始执行搬运工作 （主线程调用notifyAll，唤醒所有子线程开始执行 ）
 
public class TestNotify implements Runnable{

	private  Integer counter=0; 
	private String waitObj ; 
	
	public TestNotify(String wait,int counter2 ) {
		this.waitObj=wait ; 
		this.counter = counter2 ; 
	}

	public static void main(String[] args) {
		String wait1 = "" ; 
		
		for(int i=0;i<3;i++){
			TestNotify d = new TestNotify(wait1,i);
			new Thread(d).start(); 
		}
		
		try {
			Thread.sleep(10000);
			System.out.println( " 主线程结束 ");
			synchronized (wait1) {
				wait1.notifyAll();
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void run() {
		 synchronized (waitObj) {
			try {
				System.out.println("子线程启动=="+counter);
				Thread.sleep(2000);
				waitObj.wait();
				
				System.out.println("子线程结束"+counter);
			} catch ( Exception e) {
				e.printStackTrace();
			}
		}
	}
	
}

 
结果分析：子线程 0,1,2都计入wait后主线程调用notifyAll，则子线程开始执行wait后面代码；
 
子线程启动==0
子线程启动==2
子线程启动==1
 主线程结束 
子线程结束1
子线程结束2
子线程结束0
 
 

sleep：调用sleep使任务进入休眠状态，任务在指定的时间内不会运行，锁没有被释放。

yield:此刻让出cpu,所有线程再次竞争cpu使用权，锁未被释放

如果Thread1和Thread2都使用synchronized (object),Thread1调用yield,Thread2也不会被执行，要等object锁被释放才可以。

wait：使线程挂起，知道线程得到了notify或notifyAll消息，线程才会进入就绪状态，锁被释放。

notify：唤醒一个正在wait当前对象锁的线程，并让它拿到对象锁

notifyAll：唤醒所有正在wait前对象锁的线程,所有的线程只是跳出了wait状态，接下来它们还会是竞争对象锁

//			object类的notify()，notifyall(),wait,wait(long),wait(long,int)
//			object.wait();  使拥有当前对象object的线程进入睡眠状态，放弃锁release lock；
//			notify() 通知在对象上因调用wait()而处于睡眠状态的某一线程启动；
//			notifyAll() 通知在对象上因调用wait()而处于睡眠状态的所有线程启动，这些进程根据优先级顺序执行；

class Q {
	int n;
	boolean valueSet = false;

	public synchronized int get() {
		if (!valueSet)
			try {
				this.wait(); // 使当前使用该对象的线程睡眠
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		System.out.println("Get n = " + n);
		valueSet = false;
		notify(); // 通知一个线程可以调用该线程了
		return n;
	}

	public synchronized void put(int n) {
		// if valueSet == true,already have value so wait fetch,else put
		if (valueSet)
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		this.n = n;
		System.out.println("Put n = " + n);
		valueSet = true;
		notify();
	}
}

class Producer implements Runnable {
	Q q = null;

	Producer(Q q) {
		this.q = q;
		(new Thread(this, "Producer")).start();
	}

	@Override
	public void run() {
		int i = 0;
		while (i < 10) {
			q.put(i++);
		}
	}
}

class Consumer implements Runnable {
	Q q = null;

	public Consumer(Q q) {
		this.q = q;
		(new Thread(this, "Consumer")).start();
	}

	@Override
	public void run() {
		while (q.get() < 9) {
		}
	}
}

public class DemoThread {
	public static void main(String[] args) {
		Q q = new Q();

		new Consumer(q);
		new Producer(q);
	}
}
 

背景: 在编写生产者 / 消费者代码时, 遇到了一些奇怪的现象, 例如超额生产 / 超额消费, 而这些的原因是由于我们对 wait notify notifyAll 的理解不正确
下面有一些多线程下使用  wait notify notifyAll 注意事项

wait notify notifyAll 都要放在 synchronized 方法 / 代码块中, 否则运行异常 java.lang.IllegalMonitorStateException
 务必在 while 而不是 if 中使用 wait (). 因为当 wait () 被唤醒后, 此时条件可能已经改变, 是需要应该再次校验是否满足条件, 而不是直接往下运行代码. 索引使用 while 而不是 if
 使用 notifyAll () 而不是 notify (). notify () 表示通知某一个线程, 而 notifyAll () b 表示通知所有等待此锁的线程. 因为在多线程下, 如果仅仅使用 notify () 来通知其他线程, 可能会通知到相同类型的线程, 例如消费者线程通知到其他消费者线程, 这会导致生产者线程无法被通知到, 一直处于 wait () 的状态