包子类&包子铺类-吃货类&测试类

包子类&包子铺类

资源类:包子类设置包子的属性
皮
陷
包子的状态:有true,没有false

package Demo01.WaitAndNotify;

/**
 * 资源类:包子类设置包子的属性
 * 皮
 * 陷
 * 包子的状态:有true,没有false
 */
public class BaoZi {
    //皮
    String pi;
    //陷
    String xian;
    //包子的状态:有true,没有false,设置初始值为false没有包子
    boolean flag =false;


}

 

package Demo01.WaitAndNotify;

/*
生产者(包子铺)类:是一个线程类,可以继承Thread设置线程任务(run ):生产包子
对包子的状态进行判断
true:有包子
包子铺调用wait方法进入等待状态false:没有包子
包子铺生产包子
增加一些趣味性:交替生产两种包子
有两种状态(i%2==0)
包子铺生产好了包子
修改包子的状态为true有
唤醒吃货线程,让吃货线程吃包子

 */
public class BaoZuPu extends Thread {
    private final BaoZi bz;

    public BaoZuPu(BaoZi bz) {
        this.bz = bz;
    }

    @Override
    public void run() {
        while (true) {
            //定义一个变量
            int count = 0;
            //必须同时同步技术保证两个线程只能有一个在执行
            synchronized (bz) {
                //对包子的状态进行判断
                if (bz.flag == true) {
                    //包子铺调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                //被唤醒之后执行,包子铺生产包子
                //增加一些趣味性,交替生产两种包子

                if (count % 2 == 0) {
                    //生产 薄皮
                    bz.pi = "薄皮";
                    bz.xian = "三鲜陷";
                } else {
                    //生产 薄皮
                    bz.pi = "冰皮";
                    bz.xian = "牛肉大葱陷";
                }
                count++;
                System.out.println("包子铺正在生产:" + bz.pi + bz.xian + "包子");
                //生产包子需要3秒钟
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //包子铺生产好了包子
                //修改包子的状态为true有
                bz.flag = true;
                //唤醒吃货线程,让吃或线程吃包子
                bz.notify();
                System.out.println("包子铺已经生产好了:" + bz.pi + bz.xian + "包子,吃货可以开始了");
            }
        }
    }
}

 

吃货类&测试类

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

package Demo01.WaitAndNotify;

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

 */
public class ChiHuo extends Thread {
    private final BaoZi bz;

    public ChiHuo(BaoZi bz) {
        this.bz = bz;
    }

    //设置线程任务(run):吃包子
    @Override
    public void run() {
        //使用死循环,让吃货一直吃包子
        while (true) {
            //必须同时同步技术保证两个线程只能有一个在执行
            synchronized (bz) {
                //对包子的状态进行判断
                if (bz.flag == false) {
                    //吃货调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //被唤醒之后执行的代码.吃包子
                System.out.println("吃货正在吃"+bz.pi+bz.xian+"的包子");
                //吃货吃完包子
                //修改包子的状态为false
                bz.flag=false;
                //吃货唤醒包子铺线程,生产包子
                bz.notify();
                System.out.println("吃货已经把"+bz.pi+bz.xian+"的包子吃完了,包子铺开始成生产包子");
                System.out.println("----------------------------------------------------------");

            }
        }

    }
}

package Demo01.WaitAndNotify;
/*
测试类;
包含main方法,程序执行的入口,启动程序创建包子对象;
创建包子铺线程,开启,生产包子;创建吃货线程,开启,吃包子;

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