传智黑马Java → 30等待唤醒机制（包子铺生产、卖包子，吃货吃包子）需求分析及代码实现

包子类： 

package Section_4._2;
/*
    资源类：包子类
    设置属性：
        皮
        馅
        包子状态：true false
 */
public class BaoZi {
    String pi;
    String xian;
    boolean flag = false;
}

包子铺（线程）类： 

package Section_4._2;
/*

    生产者（包子铺）类：是一个 线程类，继承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 count = 0;
        // 让包子铺一直生产包子
        while (true) {
            // 必须使用同步技术保证两个现场只有一个执行
            synchronized (bz) {
                // 对包子的状态进行判断
                if (bz.flag) {
                    // 包子铺调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // 被唤醒之后执行，生产包子
                // 交替生产两种包子
                if (count++ % 2 == 0) {
                    // 生产薄皮三鲜馅包子
                    bz.pi = "薄皮";
                    bz.xian = "三鲜馅";
                } else {
                    // 生产冰皮牛肉大葱馅包子
                    bz.pi = "冰皮";
                    bz.xian = "牛肉大葱馅";
                }
                System.out.println("包子铺正在生产" + bz.pi + bz.xian + "包子。");
                // 生产包子需要3秒钟
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            /*
                修改包子的状态为true有
                唤醒吃货线程，让吃货线程吃包子
             */
                bz.flag = true;
                bz.notify();
                System.out.println("包子铺已经生产好了：" + bz.pi + bz.xian + "包子，吃货可以开始吃了。");
            }
        }
    }
}

吃货（线程）类 ：

package Section_4._2;
/*
    消费者（吃货）类，是一个线程类，继承Thread
    设置线程任务（run）:吃包子
    对包子状态进行判断
    false：没有包子
        吃货调用wait方法进入等待状态
    true：有包子
        吃货吃包子
        吃完包子修改包子false
        唤醒包子铺线程，生产包子
 */
public class ChiHuo extends Thread {
    // 1，需要在成员位置创建一个包子变量
    private final BaoZi bz;
    // 2，使用带参数构造方法。为这个包子变量赋值
    public ChiHuo(BaoZi bz) {
        this.bz = bz;
    }

    // 设置线程任务（run）:吃包子
    @Override
    public void run() {
        // 让吃货一直吃包子
        while (true) {
            // 必须使用同步技术保证两个现场只有一个执行
            synchronized (bz) {
                // 对包子状态进行判断
                if (!bz.flag) {
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // 被唤醒之后执行的代码，吃包子
                System.out.println("吃货正在吃：" + bz.pi + bz.xian + "的包子");
                try {
                    Thread.sleep(10000); // 吃10s
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                /*
                    吃完包子修改包子false
                    唤醒包子铺线程，生产包子
                */
                bz.flag = false;
                bz.notify();
                System.out.println("吃货已经把：" + bz.pi + bz.xian + "的包子吃完了，包子铺开始生产包子。");
                System.out.println("==================");
            }
        }
    }
}

测试类：

 

package Section_4._2;
/*
    测试类：
    包含main方法，程序执行入口，启动程序
    创建包子对象
    创建包子铺线程，开启，生产包子
    创建吃货线程，开启，吃包子
 */
public class Test {

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

}