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

本文主要是介绍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,3
printerA prints 1
printerA prints 2
printerA prints 3
PrinterA printed 1,2,3; notify PrinterB
printerB waited for printerA printed 1,2,3
printerB prints 4
printerB prints 5
printerB prints 6
notify in printerB
notify end printerB
PrinterB exits.
wait end printerA
printerA prints 7
printerA prints 8
printerA prints 9
PrinterA 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异常

这篇关于java线程同步：使用Object的wait,notify,notifyAll做线程调度的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---