Java并发编程|Java并发编程 - 等待/通知 Java并发编程-等待

Java语言为线程的通信提供了支持，其中的一种方式就是等待/通知机制，java.lang.Object的wait、notify和notifyAll方法为这种机制的实现提供了支持。
现在有这样的一个场景：假如你是一个畅销书作者，正在写一本书，书写完后读者来购买。
【Java并发编程|Java并发编程 - 等待/通知】从编程的角度出发，你和读者（现在假设就只有一个人愿意买）分别都是一个线程，你这个线程做的事就是写书，读者这个线程就是等你写完后买书。
下面这个场景伪代码

// 读者 thread a : 我在等作者写书 ...... 作者通知我了，我买到书了// 作者 thread b: 我在写书 ...... 我书写好了，通知读者

伪代码的逻辑把这个场景描述出来了。不过，稍微思考一下，这样符合逻辑吗？读者和作者很熟？有很多读者要买书的话，作者一个一个联系？
直接让读者和作者联系，似乎是不明智的选择。从编程语言的角度看，让很多很多的线程彼此之间直接交互，不管编程语言是否能提供很好的实现机制，这样做觉得不是很可取。
现在怎么办？这时候作者联系到了一个书店老板，告诉他说：书写好了，你就帮我卖；读者也找到了作者联系的这个老板，跟他说：有书卖了通知我。
也就是作者和读者的通过书店老板这个中间人联系起来了。
那么对于这种场景，Java编程语言是否是，或者说是否能按照提供中间人这种解决方式来操作呢？
现在看看对这个场景描述的Java代码：
一个读者买书

public class BookTrade {public static void main(String[] args) throws InterruptedException {// 书店老板 Object object = new Object(); // 作者 Thread threadA = new Thread(new Runnable() { @Override public void run() { synchronized (object) { // 和书店老板取得联系 System.out.println(Thread.currentThread().getName() + "在写书..."); try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "写好书了..."); // 书店老板通知联系过他的那个读者 object.notify(); } } }, "作者"); // 读者 Thread threadB = new Thread(new Runnable() { @Override public void run() { synchronized (object) { // 和书店老板取得联系 System.out.println(Thread.currentThread().getName() + "在等着买书..."); try { object.wait(); // 一直在等 } catch (InterruptedException e) { e.printStackTrace(); }System.out.println(Thread.currentThread().getName() + "买到书了..."); } } }, "读者"); threadA.start(); threadB.start(); } }

上面是我们学过了wait、notify和notifyAll之后写出来的代码，我们可以看到是模拟的中间人这种思想来编写的，没有使得作者线程和读者现场直接交流，而且编程可以发现，两个线程之间也没法直接交流。
运行代码，发现输出是这样：

作者在写书... 作者写好书了... 读者在等着买书...

程序没有停止，打印线程的堆栈信息，发现是这样的：

文章图片
读者线程堆栈.png 读者线程是WAITING状态，书店老板的通知没起作用呢？
为什呢？
直接看如下说明：
Java中内置的同步机制是通过Monitor（管程或监视器）实现的，监视器保护程序内的临界区代码，保证同一个时刻只有一个线程在临界区代码内工作，以此来保证在多线程环境下能够安全地操作共享数据。这样就要求进入临界区之前首先要获得一个监视器，同时锁定监视器，临界区代码执行结束后，当前线程会解锁监视器，在解锁监视器之前，其他线程无法得到监视器的使用权，这样就没法进入临界区，只有等到拥有监视器使用权的线程解锁放弃监视器的使用权后才能争夺使用权。Java中每个对象都关联一个监视器，那么就可以从任何一个对象身上获取到监视器，从而进入到临界区。语言级别层面的关键字synchronized为这种获取提供了知识，只要正确按照synchronized的使用语法书写代码就能保证我们获取到监视器。
同时，Java中每个对象还关联了一个等待集合，这个等待集合是个线程集合，存放的是先前获取到对象监控器所有权然后又暂时放弃掉的线程，获取对象监视器所有权后，通过调用对象的wait方法，就可以让当前执行的线程放弃监视器所有权，然后被放入到对象关联的等待集合中。等待集合中的这个线程处于等待状态，但是可以被唤醒，被唤醒的同时会被移出等待集合，当再次获取到对象监视器使用权后就可以继续工作。notify和notifyAll方法提供了唤醒功能的支持，负责唤醒的那个线程通过调用对象的notify方法或notifyAll方法就可以唤醒对象关联的等待集合中的线程。notify方法只会唤醒一个线程，当对象关联的等待集合中有多个等待线程，那么唤醒哪个线程是不确定的。notifyAll会唤醒对象关联的等待集合中的所有线程。
好了，理论知识已经说得很明确了，那么我们说说上面代码的问题所在，我们运行代码发现作者线程先执行了，这个线程获取到了书店老板这个对象的监视器，那么读者这个线程就无法执行了，读者线程中的wait方法此时不会执行到，也就没法将它放置到书店老板对象的等待集合中。作者线程休眠5秒后，执行notify方法，但是此时书店老板对象的等待集合是空的，这个方法的调用实际上没有效果的。作者线程执行完，对书店老板对象的监视器进行了解锁，释放掉了所有权。之后，读者线程获取到了监视器的使用权，进入代码中执行wait方法，wait方法这次会把读者线程放到书店老板的等待集合中，但是代码中此时没有其他唤醒它的线程了，所以读者线程会一直处于WAITTING状态。
怎么改呢？我们只要保证读者线程先执行就可以了。
这其实就是谁先跟老板联系的问题，读者先联系符合等待/通知的机制，作者先跟老板联系，书写好了，读者还没跟老板联系，他通知谁去，是这个道理吧。
将最后两行代码改成这样：

threadB.start(); Thread.sleep(1000); threadA.start();

上面说到对象的等待集合中有多个等待线程，调用notify方法不会确保哪个具体线程被调用，下面我们就来看看多读者的情景。
多个读者买书

public class BookTradeMutiple {public static void main(String[] args) throws InterruptedException {// 书店老板 Object object = new Object(); // 作者 Thread writer = new Thread(new Runnable() { @Override public void run() { synchronized (object) {// 和书店老板取得联系 System.out.println(Thread.currentThread().getName() + "在写书..."); try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "写好书了..."); // 书店老板通知联系过他的那个读者 object.notify(); } } }, "作者"); // 买书 Runnable runnable = new Runnable() { @Override public void run() { synchronized (object) {// 和书店老板取得联系 System.out.println(Thread.currentThread().getName() + "在等着买书..."); try { object.wait(); // 一直在等 } catch (InterruptedException e) { e.printStackTrace(); }System.out.println(Thread.currentThread().getName() + "买到书了..."); } } }; new Thread(runnable, "读者1").start(); new Thread(runnable, "读者2").start(); new Thread(runnable, "读者3").start(); new Thread(runnable, "读者4").start(); new Thread(runnable, "读者5").start(); new Thread(runnable, "读者6").start(); Thread.sleep(1000); writer.start(); }}

运行代码可以看到，只会有一个读者买到书，其他读者线程最后都处于WAITING状态。

我代码中可以看到的是每次都是读者1买到书，读者1的线程先执行的wait方法，是否是先放到等待集合中的线程先被唤醒呢？这个没有这个明确地规定，Java语言规范中说到的是：There is no guarantee about which thread in the wait set is selected. 这里我们就不做考究了。

将notify改成notifyAll，然后做测试，所有的读者都买到书了。

读者1在等着买书... 读者2在等着买书... 读者3在等着买书... 读者4在等着买书... 读者5在等着买书... 读者6在等着买书... 作者在写书... 作者写好书了... 读者6买到书了... 读者5买到书了... 读者4买到书了... 读者3买到书了... 读者2买到书了... 读者1买到书了...