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 + "包子,吃货可以开始了");

            }

        }

    }

}

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();

    }

}