JAVA学习の等待唤醒机制（包子铺案例）

一、什么时等待唤醒机制

形象的说
这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争( race) ,比如去争夺锁,但这并不是故事的全部,线程间也会有协作机制。就好比在公司里你和你的同事们,你们可能存在在晋升时的竞争,但更多时候你们更多是- -起合作以完成某些任务。
抽象来讲
就是在一个线程进行了规定操作后,就进入等待状态( wait())，等待其他线程执行完他们的指定代码过后再将其唤醒( notify() ) ;在有多个线程进行等待时，如果需要,可以使用notifyAl()来唤醒所有的等待线程。

wait/notify就是线程间的一种协作机制。

二、等待唤醒中的方法

等待唤醒机制就是用于解决线程间通信的问题的,使用到的3个方法的含义如下:

1、wait:线程不再活动,不再参与调度,进入waitset中,因此不会浪费CPU资源,也不会去竞争锁了,这时的线程状态即是WAITING。它还要等着别的线程执行一个特别的动作 ,也即是"通知( notify)”在这个对象上等待的线程从wait set中释放出来,重新进入到调度队列( ready queue )中

2、 notify :则选取所通知对象的wait set中的一-个线程释放;例如,餐馆有空位置后,等候就餐最久的顾客最先入座。

3、notifyAll :则释放所通知对象的wait set上的全部线程。

三实际案例（包子铺案例）

包子铺线程生产包子，吃货线程消费包子。
当包子没有时(包子状态为false) , 吃货线程等待，
包子铺线程生产包子(即包子状态为true) ,
并通知吃货线程(解除吃货的等待状态) ,
因为已经有包子了，那么包子铺线程进入等待状态。
接下来，吃货线程能否进一步执行则取决于锁的获取情况。
如果吃货获取到锁，那么就执行吃包子动作，包子吃完(包子状态为false)，并通知包子铺线程(解除包子铺的等待状态) , 吃货线程进入等待。
包子铺线程能否进一-步执行则取决于锁的获取情况。

①创建包子类

public class BaoZi {
    String pi=new String();
    String xian=new String();
    //包子的状态（有无）
    boolean flag=false;
}

②创建包子铺线程类
特别注意：
1、由于我们要生产不同种类的包子（通过count%2来判断生产那一类）
此时count必须时全局变量
不能再while死循环中（死循环中会自动重新赋值）
2、wait方法、sleep方法必须处理异常
3、必须创建带参数的构造方法，便于main方法调用
4、包子生产完后记得该flag（包子的状态）

public class BaoZiPu extends Thread{
    BaoZi baozi=new BaoZi();

    public BaoZiPu(BaoZi baozi) {
        this.baozi=baozi;
    }

    @Override
    public void run() {
        int count=1;
        while (true){//让包子铺不停的吃包子

            synchronized (baozi){//使用同步技术保正只有一下线程在执行
                //有包子包子铺停止做包子
                if(baozi.flag==true){
                    try {
                        baozi.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    //没有包子开始做包子


                    if(count%2==0){
                        baozi.pi="冰皮";
                        baozi.xian="三鲜馅";
                        System.out.println("包子铺正在生产"+baozi.pi+baozi.xian+"的包子");

                    }else{
                        baozi.pi="蛇皮";
                        baozi.xian="猪肉馅";
                        System.out.println("包子铺正在生产"+baozi.pi+baozi.xian+"的包子");

                    }
                    count++;
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("包子生产完成");
                    baozi.flag=true;
                    //唤醒吃货开始吃包子
                    baozi.notify();

                }
            }
        }
    }
}

③创建吃货线程类
特别注意：
1、必须调用带参数的构造方法便于main方法调用
2、wait异常必须处理
3、包子吃完完后记得该flag（包子的状态）
4、同步技术

public class Foodie extends Thread{
    BaoZi baozi=new BaoZi();
    public Foodie(BaoZi baozi) {
        this.baozi=baozi;
    }

    @Override
    public void run() {
        while (true){//让吃货不停的执行
            synchronized (baozi){//使用同步技术保正只有一下线程在执行
                if(baozi.flag==false){
                    try {
                        baozi.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    //开始吃包子
                    System.out.println("Foodie正在吃"+baozi.pi+baozi.xian+"的包子");
                    System.out.println("========================================");
                    //改变包子的状态
                    baozi.flag=false;
                    //唤醒包子铺
                    baozi.notify();
                }
            }
        }
    }
}

④创建main方法执行
特别注意：
1、通过带参的构造方法来开启两个线程、且两个线程的参数需要相同
以实现等待与唤醒

public class demo {
    public static void main(String[] args) {
        BaoZi baozi=new BaoZi();
        new BaoZiPu(baozi).start();
        new Foodie(baozi).start();
    }
}

⑤运行结果