java中wait/notify机制

通常，多线程之间需要协调工作。例如，浏览器的一个显示图片的线程displayThread想要执行显示图片的任务，必须等待下载线程 downloadThread将该图片下载完毕。如果图片还没有下载完，displayThread可以暂停，当downloadThread完成了任务 后，再通知displayThread“图片准备完毕，可以显示了”，这时，displayThread继续执行。
以上逻辑简单的说就是：如果条件不满足，则等待。当条件满足时，等待该条件的线程将被唤醒。在Java中，这个机制的实现依赖于wait/notify。等待机制与锁机制是密切关联的。例如：
synchronized(obj) {while(!condition) {obj.wait();}obj.doSomething();}  

当线程A获得了obj锁后，发现条件condition不满足，无法继续下一处理，于是线程A就wait()。
在另一线程B中，如果B更改了某些条件，使得线程A的condition条件满足了，就可以唤醒线程A：
synchronized(obj) {condition = true;obj.notify();} 

需要注意的概念是：
◆调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) {...} 代码段内。
◆调用obj.wait()后，线程A就释放了obj的锁，否则线程B无法获得obj锁，也就无法在synchronized(obj) {...} 代码段内唤醒A。
◆当obj.wait()方法返回后，线程A需要再次获得obj锁，才能继续执行。
◆如果A1,A2,A3都在obj.wait()，则B调用obj.notify()只能唤醒A1,A2,A3中的一个（具体哪一个由JVM决定）。
◆obj.notifyAll()则能全部唤醒A1,A2,A3，但是要继续执行obj.wait()的下一条语句，必须获得obj锁，因此，A1,A2,A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj锁之后才能继续执行。

◆当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此，A1,A2,A3虽被唤醒，但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1,A2,A3中的一个才有机会获得锁继续执行。

在JAVA中，是没有类似于PV操作、进程互斥等相关的方法的。JAVA的进程同步是通过synchronized()来实现的，需要说明的是，JAVA的synchronized()方法类似于操作系统概念中的互斥内存块，在JAVA中的Object类型中，都是带有一个内存锁的，在有线程获取该内存锁后，其它线程无法访问该内存，从而实现JAVA中简单的同步、互斥操作。明白这个原理，就能理解为什么synchronized(this)与synchronized(static XXX)的区别了，synchronized就是针对内存区块申请内存锁，this关键字代表类的一个对象，所以其内存锁是针对相同对象的互斥操作，而static成员属于类专有，其内存空间为该类所有成员共有，这就导致synchronized()对static成员加锁，相当于对类加锁，也就是在该类的所有成员间实现互斥，在同一时间只有一个线程可访问该类的实例。如果只是简单的想要实现在JAVA中的线程互斥，明白这些基本就已经够了。但如果需要在线程间相互唤醒的话就需要借助Object.wait(), Object.nofity()了。

    Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内。从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。

下面放上轮番打印A/B的程序，供思考

package testThread;

public class PrintSort {
	
	public static void main(String[] args) throws InterruptedException{
		Object a = new Object();
		Object b = new Object();
		
		PrintThread one = new PrintThread("A",a,b);
		PrintThread two = new PrintThread("B",b,a);
		
		new Thread(one).start();
		Thread.sleep(2000);
		new Thread(two).start();
	}
	
	
}
class PrintThread implements Runnable{
	private String printStr;
	private Object lockA;
	private Object lockB;
	public PrintThread(String str,Object a,Object b){
		printStr = str;
		lockA = a;
		lockB = b;
	}
	@Override
	public void run() {
		for(;;){
			synchronized(lockA){
				synchronized(lockB){
					System.out.println(printStr);
					lockB.notify();
			}
				try {
					lockA.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		}
	}
	}
	
	
}

运行结果：

A

（等2S）

B

A

B

……

简单分析一下，ONE线程开始后：依次a、b对象锁（synchronized块），在b锁内部时，打印A，同时通知另一个线程TWO（准确的说，应该是JVM），类似这样：“我这处理完了，我马上把b对象锁放开（synchronized（b)此时还没结束），你先做好准备。”但此时two线程还没开始，继续向下运行，到ONE的lockA.wait()时，One线程释放了a锁，停下来休眠等着了。

2S钟后，TWO线程启动，two线程的a,b对象对应的one线程的b,a对象（ONE的LOCKA对应TWO的LOCKB，ONE的LOCKB对应TWO的LOCKA），由于b,a锁此时都被ONE线程释放了，所以TWO线程一路向下走，依次锁定b,a对象，打印B之后，TWO线程通知JVM，我要释放LOCKB锁了（对应ONE线程的LOCKA），哪个线程跟那WAIT我的LOCKB对象，做好唤醒准备，two调用lockB.notify()后，放了b锁，之后lockA.wait()时，two又把a锁放了，ONE线程唤醒后由于A\B锁都已经被TWO释放了，打印“A"。。。之后往复这个过程。