目录
等待唤醒机制即通过wait和notify实现多线程之间的通信，进而实现多线程协同工作。
1.普通生产者与消费者方式
生产者和消费者是一种经典的多线程协同工作模式，以厨师（生产者）和顾客（消费者）为例：
厨师和顾客中间有张桌子，厨师会将做好的饭放到桌子上，顾客需要从桌子上拿到饭并吃掉。初始状态下厨师还没有做饭，桌子上是空的，顾客也还没有开始吃饭。
对于厨师而言，他要做以下五种事情：
- 检查桌子上是否还有饭
- 如果桌子上有饭则等待顾客吃完
- 如果没有，则开始做饭
- 将做好的饭放到桌子上
- 通知顾客来吃
对于顾客而言，他要做以下四种事情：
- 检查桌子上是否有饭
- 如果没有饭则等待厨师做好饭
- 如果有饭则开始吃饭
- 吃完饭后通知厨师继续开始做饭
如果用代码实现上面的通知和等待，则要用到下面三种方法：
其中通知经常是用notifyAll，因为如果线程有很多，使用notify仅能随机唤醒一个线程，那可能要唤醒好多次才能唤醒所需要的线程，而notifyAll能唤醒所有线程，自然也会唤醒所需要的线程，所以一般使用notifyAll用来通知。
用代码实现上面的顾客、厨师以及桌子：
//桌子Table
public class Table {
//桌子上是否有饭的信号，0代表没有饭，1代表有饭
public static int flag=0;
//顾客吃饭的目标
public static int count=3;
//顾客和厨师共享的锁，因为对于共享资源加的锁必须是唯一的
public static Object object=new Object();
}
//顾客Customer
public class Customer extends Thread{
@Override
public void run() {
synchronized (Table.object){
while (true){
//先检查自己是否已经达成了吃饭的目标
//如果已经达到了就break
//如果没有则进行接下来的操作
if(Table.count==0){
System.out.println("顾客达成了目标，结账走人了。");
break;
}else{
//1.先检查桌子上有没有饭
//2.如果有则执行吃饭操作
//3.如果没有则等待厨师做饭
if(Table.flag==1){
System.out.println("顾客正在吃饭中...");
//将饭从桌子上拿走
Table.flag=0;
//吃了这碗饭后离目标又近了一步
Table.count--;
System.out.println("饭吃完了，还剩"+Table.count+"碗饭没吃，正在通知厨师做饭...");
//4.吃完饭后通知厨师继续做饭
Table.object.notifyAll();
}else {
try {
Table.object.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
}
}
}
//厨师Cook
public class Cook extends Thread{
@Override
public void run() {
synchronized (Table.object) {
while (true) {
//先判断是否顾客已经达成吃饭的目标
//如果吃饭的目标达成则退出循环
//如果没有则继续接下来的操作
if(Table.count==0){
System.out.println("厨师了解到顾客达成了目标，结束做饭。");
break;
}else{
//1.先检查桌子上有没有饭
//2.如果没有则开始做饭
//3.如果有则进入等待
if(Table.flag==0){
System.out.println("厨师正在做饭中...");
//4.饭做好了，将饭放到桌子上
Table.flag=1;
//5.通知顾客来吃
//唤醒所有绑定到这个锁的线程
System.out.println("饭做好了，已放到桌子上，正在通知顾客来吃...");
Table.object.notifyAll();
}else{
try {
//绑定加上这个共享锁的线程，并让该线程进入等待状态
Table.object.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
}
}
}
//模拟顾客和厨师的过程
public class Main {
public static void main(String[] args) {
Thread t1=new Customer();
Thread t2=new Cook();
t1.start();
t2.start();
}
}运行结果：
首先要注意的是顾客和厨师是两个线程类而不是两个普通的类。然后就是Table相当于管理共享的变量，共享的变量要设置为静态的。最后就是在调用wait和notifyAll时要使用共享锁来调用，用共享锁调用wait会将这个锁和添加这个锁的线程进行绑定，在用这个共享锁调用notifyAll时会唤醒绑定这个锁的所有线程，从而在唤醒时不会通知其他无关的线程。
下面使用lambda表达式来实现：
//资源类，饭
public class Food {
//桌子上的食物数量
private int num=0;
//目标一共需要吃十碗饭
private int sumnum=10;
//厨师的做饭方法
public synchronized boolean cook() throws InterruptedException {
//检查是否达到了目标
if(sumnum==0){
return false;
}
//是否需要等待
if(num!=0){
this.wait();
}else{
//做饭的业务代码
num++;
System.out.println(Thread.currentThread().getName()+"做好了一碗饭，当前有"+num+"碗饭");
//饭做好了，通知顾客来吃
this.notifyAll();
}
return true;
}
//顾客的吃饭方法
public synchronized boolean eat() throws InterruptedException {
//检查是否达到了目标
if(sumnum==0){
return false;
}
//是否需要等待
if(num==0){
this.wait();
}else{
//吃饭的业务代码
num--;
sumnum--;
System.out.println(Thread.currentThread().getName()+"吃了一碗饭，当前有"+num+"碗饭");
//饭吃完了，通知厨师继续做
this.notifyAll();
}
return true;
}
}
//实现
public class Main {
public static void main(String[] args) {
//创建资源类Food的对象
Food food=new Food();
//创建厨师线程
Thread c1=new Thread(()->{
while (true){
try {
if(!food.cook())
break;
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"做饭线程1");
//创建顾客线程
Thread e1=new Thread(()->{
while (true){
try {
if(!food.eat())
break;
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"吃饭线程1");
//启动厨师和顾客的线程
c1.start();
e1.start();
}
}注意一定要使用if-else语句，将业务代码和通知放在else中：
//正确格式
if(等待条件){
wait;
}else{
业务代码;
notifyAll;
}
//错误格式
if(等待条件){
wait;
}
业务代码；
notifyAll;如果使用错误格式将业务代码和通知放到外面，那么这个线程在被唤醒后会接着执行业务代码，但是如果这个线程还不满足执行业务代码的条件，由于其他线程调用了notifyAll唤醒了所有的线程，那么这个线程会在不满足条件下开始执行业务代码，这就是虚假唤醒。如果将这些代码放入else中，即使这个线程在不满足条件下被唤醒也不会执行业务代码，而是会进入下一次循环，在进入下一次循环后又会判断是否满足条件。
在使用等待唤醒机制实现线程之间的通信时，可以利用口诀“等待、业务、通知”来编写要执行的方法：
//先判断是否需要等待，如果满足等待条件，执行wait
//业务代码
//使用notifyAll通知其他线程
if(等待条件){
this.wait();
}else{
业务代码
this.notifyAll();
}
2.加入阻塞队列
阻塞队列就相当于替换掉了中间的桌子，顾客吃饭时从阻塞队列中拿，厨师做好饭后将饭放到阻塞队列中；阻塞队列由于是一个队列，会遵循先入先出。桌子只能放一碗饭，而阻塞队列可以放多碗饭；并且阻塞队列的底层已经加锁了，不需要我们手动加锁。
阻塞队列有两种，一种是ArrayBlockingQueue<类型>，底层是基于数组的，所以这种阻塞队列的空间是有限的；另一种是LinkedBlockingQueue<类型>，底层是基于链表的，所以这种阻塞队列的空间理论上是无限的，但实际上它的最大长度不能超过int的范围。
用阻塞队列实现起来很简单，生产者只需要向里面放东西，也就是调用put方法，消费者只需要从里面取东西就行了，也就是调用take方法。下面是put和take的源码：
put:
take:
下面用阻塞队列来实现顾客和厨师：
//厨师
public class Cook extends Thread{
ArrayBlockingQueue<String> queue;
public Cook(ArrayBlockingQueue<String> queue){
this.queue=queue;
}
@Override
public void run() {
while (true){
try {
queue.put("饭");
System.out.println("厨师做好了一碗饭");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
//顾客
public class Customer extends Thread{
ArrayBlockingQueue<String> queue;
public Customer(ArrayBlockingQueue<String> queue){
this.queue=queue;
}
@Override
public void run() {
while (true){
try {
String food=queue.take();
System.out.println("顾客拿走了一碗饭");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
//模拟顾客和厨师的过程
public class Main {
public static void main(String[] args) {
//由于阻塞队列只能有一个，所以阻塞队列不能在Cook或Customer中创建，直接从main中创建即可
ArrayBlockingQueue<String> queue=new ArrayBlockingQueue<String>(1);
//将这个阻塞队列分别传递给Cook和Customer，保证两者使用的是同一个阻塞队列
Thread t1=new Cook(queue);
Thread t2=new Customer(queue);
t1.start();
t2.start();
}
}运行结果：
在上面的代码中， 我们给阻塞队列设置的空间为1，那应该输出的是厨师放一碗饭顾客拿一碗饭才对，而这里却出现了厨师连放多次饭以及顾客连取多次饭的情况，这难道是取和放的时候出现了问题吗？
其实并不是，因为put和take的底层已经进行了加锁和解锁的操作，所以这两个过程是没有问题的，问题出在后面的输出语句。虽然put和take进行了加锁，但是输出的操作并没有加锁，这很可能出现乱输出的情况，毕竟线程的运行完全随机，永远不知道下一秒是哪个线程在占用CPU。不过虽然输出操作会出现问题，但这对实现顾客和厨师的过程并不会产生影响，因为输出操作只是用来给自己看的，实际运行过程不出错即可。
