线程练习题生产者与消费者

//测试类
public class Test {
    public static void main(String[] args) {
        //创建包子对象
        Baozi baozi = new Baozi();
        //创建包子铺线程对象
        new Cost(baozi).start();
        //创建吃货线程对象
        new Foodie(baozi).start();
    }
}






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










//包子铺
/*
  生产者（包子铺）：是一个线程类，继承Thread类
      设置线程的任务：生产包子
  true:有包子
     包子调用wait方法进入等待状态
  false：没有包子
    包子铺生产包子
    修改包子的状态为true
    唤醒吃货线程，让吃货去吃包子
  注意：
     包子铺线程和吃货线程关系---》通信（互斥）
     必须使用同步技术保证两个线程只能有一个线程在执行
     锁对象必须保证唯一，可以使用包子对象作为锁对象
     包子铺线程和吃货线程的类需要把包子对象作为参数传递进来
       1.需要在成员的位置上创建一个包子变量
       2.使用带参构造，为这个包子变量赋值
 */
class Cost extends Thread {
    //1.需要在成员的位置上创建一个包子变量
    private Baozi baozi;

    //使用带参构造，为这个包子变量赋值
    public Cost(Baozi baozi) {
        this.baozi = baozi;
    }

    //重写run方法

    @Override
    public void run() {
        //设置线程任务：生产包子
        //定义一个变量
        int count = 0;
        //让包子铺一直生产包子
        while (true) {
            //必须保证两个线程只能有一个线程在执行
            synchronized (baozi) {
                //进行包子的状态判断
                if (baozi.flag) {
                    //包子铺有包子，包子铺需要调用wait方法进入等待状态
                    try {
                        baozi.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //包子铺没有包子，被唤醒之后，包子铺生产包子
                //增加一些难度；交替生产两种类型的包子
                if (count % 2 == 0) {
                    //生产 肉馅的包子，皮是薄皮
                    baozi.pi = "薄皮";
                    baozi.xian = "肉馅";
                } else {
                    //生产  蔬菜馅的包子，皮是厚皮
                    baozi.pi = "厚皮";
                    baozi.xian = "蔬菜馅";
                }
                count++;
                System.out.println("包子铺正在生产：" + baozi.xian +
                        baozi.pi + "包子");
                //生产包子需要有一个过程；等待1秒钟
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                //包子铺生产好了包子
                //修改包子的状态为true 有
                baozi.flag = true;
                //唤醒吃货线程，让吃货线程去吃包子

                baozi.notify();
                System.out.println("包子铺已经生产好了：" + baozi.pi
                        + baozi.xian + "包子，吃货可以去吃了。。。。");

            }

        }
    }
}







/*
 消费者（吃货类）：是一个线程类
 设置线程的任务：吃包子
  对包子的状态进行判断
  true ：有包子
    吃货吃包子
    吃货吃完包子
    修改包子的状态为false：没有包子
    吃货唤醒包子铺线程，生产包子
  false：没有包子
    吃货调用wait方法，进入到等待状态
 */
class Foodie extends Thread {
    //1.需要在成员的位置上定义一个包子变量
    private Baozi baozi;

    //2.使用带参构造，为这个包子变量赋值
    public Foodie(Baozi baozi) {
        this.baozi = baozi;

    }

    //3.重写run方法


    @Override
    public void run() {
        //设置线程任务：吃包子
        //使用死循环，让吃货一直吃包子
        while (true) {
            //使用同步技术保证两个线程只有一个线程在执行
            synchronized (baozi) {
                //对包子状态进行判断
                if (baozi.flag==false) {
                    //让吃货线程进入到等待状态
                    try {
                        baozi.wait();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                //被唤醒后执行吃包子
                System.out.println("吃货正在吃：" + baozi.pi + baozi.xian
                        + "包子");
                //吃货吃完包子
                //修改包子的状态为false没有
                baozi.flag = false;
                //吃货线程唤醒包子铺线程---》生产包子
                baozi.notify();
                System.out.println("吃货已经把" + baozi.pi + baozi.xian + "的包子吃完了");
                System.out.println("----------------------------------");
            }
        }
    }
}