waitANDnotify

今天让我们来吃包子吧，下面我将用吃包子的案例来简单说明waitANDnotify的一些用法。

代码实现：
资源类：包子类
设置包子的属性
皮
陷
包子的状态：有true，没有false

public class BaoZi {
    String pi;//皮
    String xian;//陷
    //包子的状态：有true，没有false,初始值为false没有包子
    boolean zhuangTai = false;
}

生产者（包子铺）类：是一个线程类，可以继承Thread
设置线程任务（run）：生产包子
对包子的状态进行判断
true：有包子
包子铺调用wait方法进入等待状态
false：没有包子
包子铺生产包子
增加一些趣味性：交替生产两种包子
有两种状态（i%2==0）“薄皮三鲜馅”，“冰皮大葱牛肉馅”
包子铺生产好了包子
修改包子的状态为true有
唤醒吃货线程，让吃货线程吃包子

注意：
包子铺线程和包子线程关系–>通信（互斥）
必须同时同步保证两个线程只能有一个在执行
锁对象必须保证唯一，可以使用包子对象作为锁对象
包子铺类吃货的类就需要把包子对象作为参数传递进来
1.需要在成员位置创建一个包子变量
2.使用带参数构造方法，为这个包子变量赋值

public class BaoZiPu extends Thread{
    //1.需要在成员位置创建一个包子变量
    private BaoZi bz;
    //2.使用带参数构造方法，为这个包子变量赋值
    public BaoZiPu(BaoZi bz) {
        this.bz = bz;
    }
    //设置线程任务（run）：生产包子
    @Override
    public void run() {
        int cunte = 0;
        while (true){//使用死循环让包子铺一直生产包子
            //必须同时同步技术保证两个线程只能有一个在执行
            synchronized (bz){
                //对包子状态进行判断
                if(bz.zhuangTai==true){
                    try {//包子铺调用wait方法进入等待状态
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //被唤醒之后执行，包子铺生产包子
                //增加一些趣味性：交替生产两种包子
                //有两种状态（i%2==0）"薄皮三鲜馅"，"冰皮大葱牛肉馅"
                if(cunte%2==0) {
                    bz.pi = "薄皮";
                    bz.xian = "三鲜馅";
                }else if(cunte%2==1){
                    bz.pi = "冰皮";
                    bz.xian = "大葱牛肉馅";
                }
                cunte++;
                System.out.println("包子铺正在生产："+bz.pi+bz.xian+"包子");
                try {//生产包子需要一秒
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //包子铺生产好了包子
                //修改包子的状态为true有
                bz.zhuangTai=true;
                // 唤醒吃货线程，让吃货线程吃包子
                bz.notify();
                System.out.println("包子铺已经生产好了"+bz.pi+bz.xian+"的包子,吃货可以开始吃了");
            }
        }
    }
}

消费者（吃货）类：是一个线程类，可以继承Thread
设置线程任务（run）：吃包子
对包子的状态进行判断
false：没有包子
吃货调用wait方法进入等待状态
true：有包子
吃货吃包子
吃货吃完包子
修改包子的状态为false没有
吃货唤醒包子铺线程，生产包子

public class ChiHuo extends Thread{
    //1.需要在成员位置创建一个包子变量
    private BaoZi bz;
    //2.使用带参数构造方法，为这个包子变量赋值
    public ChiHuo(BaoZi bz) {
        this.bz = bz;
    }
    //设置线程任务（run）：吃包子
    @Override
    public void run() {
        while (true){//使用死循环让吃货一直吃包子
            //必须同时同步技术保证两个线程只能有一个在执行
            synchronized (bz){
                if(bz.zhuangTai==false){//对包子的状态进行判断
                    try {//吃货调用wait方法进入等待状态
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //被唤醒之后执行的代码，吃包子
                System.out.println("吃货正在吃："+bz.pi+bz.xian+"的包子");
                //吃货吃完包子
                //修改包子的状态为false没有
                bz.zhuangTai=false;
                //吃货唤醒包子铺线程，生产包子
                bz.notify();
                System.out.println("吃货已经把："+bz.pi+bz.xian+"的包子吃完了，包子铺开始生产包子");
                System.out.println("=====[华丽的分割线]=====");
            }
        }
    }
}

测试类：
包含main方法，程序执行的入口，启动程序
创建包子对象
创建包子铺线程，开启，生产包子
创建吃货线程，开启，吃包子

public class Test01 {
    public static void main(String[] args) {
        //创建包子对象
        BaoZi bz = new BaoZi();
        //创建包子铺线程，开启，生产包子
        new  BaoZiPu(bz).start();
        //创建吃货线程，开启，吃包子
        new  ChiHuo(bz).start();
    }
}

包子座位一个桥梁，充当着锁对象的作用，希望以上案例能给你带来帮助