java线程同步：使用Object的wait,notify,notifyAll做线程调度

网址：http://outofmemory.cn/java/java.util.concurrent/thread-sync-with-object-wait-notify-notifyAll

我们知道java中的所有类的祖先都是Object，Object类有四个个方法wait(),wait(long timeout),notify(),notifyAll()，这四个方法可以用来做线程的调度或者说是线程的同步控制。

1. wait() 方法用来控制当前线程停止执行，等待其他线程对此Object实例调用notify或者notifyAll方法之后再继续执行
2. wait(long timeout) 此方法的作用和wait()类似，但是增加了一个超时的设置，如果等待时间超过了timeout设定的毫秒数，那么当前线程会继续执行
3. notify()方法从所有wait线程中选择一个线程，让它开始执行
4. notifyAll()方法通知所有等待此对象的线程，开始执行

上面的解释字面意思上很容易理解，但是实际使用起来，却并不是那么简单，我们以一个实际的例子来看下如何使用这些方法。

假定我们有两个线程要打印1到9这9个数字，要求第一个线程打印1，2，3然后停止打印，由线程2打印4，5，6，然后线程2停止打印，通知线程1继续打印7，8，9.

需求很简单，我们可以建两个Runnable类，假定为PrinterA和PrinterB，先由PrinterB等待，由PrinterA打印1，2，3；PrinterA打印完之后通知PrinterB，然后自己进入等待状态；PrintB获得PrinterA的通知之后开始打印4、5、6，打印完毕之后需要通知PrinterA；然后PrinterA得到通知之后开始打印剩下的7、8、9。任务就完成了。

package cn.outofmemory.threading;public class WaitNotifyDemo {private volatile int val = 1;private synchronized void printAndIncrease() {System.out.println(Thread.currentThread().getName() + " prints " + val);val++;}// print 1,2,3 7,8,9public class PrinterA implements Runnable {@Overridepublic void run() {while (val <= 3) {printAndIncrease();}// print 1,2,3 then notify printerBsynchronized (WaitNotifyDemo.this) {System.out.println("PrinterA printed 1,2,3; notify PrinterB");WaitNotifyDemo.this.notify();}try {while (val <= 6) {synchronized (WaitNotifyDemo.this) {System.out.println("wait in printerA");WaitNotifyDemo.this.wait();}}System.out.println("wait end printerA");} catch (InterruptedException e) {e.printStackTrace();}while (val <= 9) {printAndIncrease();}System.out.println("PrinterA exits");}}// print 4,5,6 after printA print 1,2,3public class PrinterB implements Runnable {@Overridepublic void run() {while (val < 3) {synchronized (WaitNotifyDemo.this) {try {System.out.println("printerB wait for printerA printed 1,2,3");WaitNotifyDemo.this.wait();System.out.println("printerB waited for printerA printed 1,2,3");} catch (InterruptedException e) {e.printStackTrace();}}}while (val <= 6) {printAndIncrease();}System.out.println("notify in printerB");synchronized (WaitNotifyDemo.this) {WaitNotifyDemo.this.notify();}System.out.println("notify end printerB");System.out.println("PrinterB exits.");}}public static void main(String[] args) {WaitNotifyDemo demo = new WaitNotifyDemo();demo.doPrint();}private void doPrint() {PrinterA pa = new PrinterA();PrinterB pb = new PrinterB();Thread a = new Thread(pa);a.setName("printerA");Thread b = new Thread(pb);b.setName("printerB");// 必须让b线程先执行，否则b线程有可能得不到锁，执行不了wait，而a线程一直持有锁，会先notify了b.start();a.start();}}

我们先把所有代码奉上了，你可以自己调试代码，在实际执行中来了解代码的实现机制。下面我们逐步分析下我们是如何控制两个线程调度的。

首先看main方法，在main方法中我们初始化了一个WaitNotifyDemo实例，然后调用了这个实例的doPrint方法。

在doPrint方法中我们使用PrinterA和PrinterB的实例初始化了两个线程，然后启动他们。

private void doPrint() {PrinterA pa = new PrinterA();PrinterB pb = new PrinterB();Thread a = new Thread(pa);a.setName("printerA");Thread b = new Thread(pb);b.setName("printerB");// 必须让b线程先执行，否则b线程有可能得不到锁，执行不了wait，而a线程一直持有锁，会先notify了b.start();a.start();}

这里需要注意必须让b线程先执行，这样b线程才能先获得WaitNotifyDemo实例上的锁，并开始等待。在PrinterB的run方法中开始等待的代码片段如下：

                       while (val < 3) {synchronized (WaitNotifyDemo.this) {try {System.out.println("printerB wait for printerA printed 1,2,3");WaitNotifyDemo.this.wait();System.out.println("printerB waited for printerA printed 1,2,3");} catch (InterruptedException e) {e.printStackTrace();}}}

这里有一个while循环，如果val的值小于3，那么在WaitNotifyDemo的实例的同步块中调用WaitNotifyDemo.this.wait()方法，这里要注意无论是wait，还是notify，notifyAll方法都需要在其实例对象的同步块中执行，这样当前线程才能获得同步实例的同步控制权，如果不在同步块中执行wait或者notify方法会出现java.lang.IllegalMonitorStateException异常。另外还要注意在wait方法两边的同步块会在wait执行完毕之后释放对象锁。

这样PrinterB就进入了等待状态，我们再看下PrinterA的run方法：

                       while (val <= 3) {printAndIncrease();}// print 1,2,3 then notify printerBsynchronized (WaitNotifyDemo.this) {System.out.println("PrinterA printed 1,2,3; notify PrinterB");WaitNotifyDemo.this.notify();}try {while (val <= 6) {synchronized (WaitNotifyDemo.this) {System.out.println("wait in printerA");WaitNotifyDemo.this.wait();}}System.out.println("wait end printerA");} catch (InterruptedException e) {e.printStackTrace();}

这里首先打印了1、2、3，然后在同步块中调用了WaitNotifyDemo实例的notify方法，这样PrinterB就得到了继续执行的通知，然后PrinterA进入等待状态，等待PrinterB通知。

我们再看下PrinterB run方法剩下的代码：

while (val <= 6) {printAndIncrease();}System.out.println("notify in printerB");synchronized (WaitNotifyDemo.this) {WaitNotifyDemo.this.notify();}System.out.println("notify end printerB");System.out.println("PrinterB exits.");

PrinterB首先打印了4、5、6，然后在同步块中调用了notify方法，通知PrinterA开始执行。

PrinterA得到通知后，停止等待，打印剩下的7、8、9三个数字，如下是PrinterA run方法中剩下的代码：

while (val <= 9) {printAndIncrease();}

整个程序就分析完了，run下程序，控制台输出如下：

printerB wait for printerA printed 1,2,3printerA prints 1printerA prints 2printerA prints 3PrinterA printed 1,2,3; notify PrinterBprinterB waited for printerA printed 1,2,3printerB prints 4printerB prints 5printerB prints 6notify in printerBnotify end printerBPrinterB exits.wait end printerAprinterA prints 7printerA prints 8printerA prints 9PrinterA exits

从输出内容上也可以看到wait，notify的执行过程。

在用wait，notify做线程同步是要特别注意下面两点：

1. 不要选择字符串，Integer，Long，Type之类的对象做同步对象，因为这些类型在jvm中都有一些特殊的处理，有可能会有意想不到的情况。比如Integer，JVM对小于128的数字做了cache，如果你用Integer做同步对象的话，可能不同的逻辑锁定了相同的同步块。这类问题调试起来也不好调试，所以最好避免这样使用。
2. 在调用obj.notify(),obj.wait方法时要在synchronized(obj)块中进行调用，否则会出现java.lang.IllegalMonitorStateException异常