多线程间之包子问题,生产者与消费者

包子类

public class BaoZi {// 包子
    String OutSide; // 皮
    String InSide;  // 馅
    boolean flag = false; // 默认 没有包子
}

生产者

// 包子铺 ,生产者,是一个线程类

/**
 生产者 是一个线程类,继承 Thread类
 设置线程的任务时 生产包子
 true 有包子
 包子铺调用 wait 方法 进入等待状态
 false 没有包子
 增加难度,交替生产两种包子
 两种状态 ( i % 2 == 0)
 包子铺生产包子
 修改包子的状态为 true
 提醒吃货线程,让吃货去吃包子

 注意
 包子铺线程和吃货线程关系,通信(互斥)
 必须使用同步技术保证两个线程 只有 有一个线程在执行
 锁对象 必须保证唯一,可以使用 包子 对象,作为锁对象
 包子铺 线程 和吃货线程 需要把包子对象作为参数传递进来

 1.需要在成员的位置上创建一个包子变量
 2.使用带参构造,为这个包子变量赋值

 */
public class Producer extends Thread{

    // 1.需要在成员的位置上创建一个包子变量
    private BaoZi baozi;
    // 2.使用带参构造,为这个包子变量赋值
    public Producer(BaoZi baozi){
        this.baozi = baozi;
    }

    @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.OutSide = "薄皮";
                    baozi.InSide = "三鲜";
                }else{
                    baozi.OutSide = "冰皮";
                    baozi.InSide = "猪肉大葱";
                }
                count++ ;
                System.out.println("包子铺正在生产,第"
                        +count+"个 , "+baozi.InSide+" "+baozi.OutSide+"包子");
                // 生产包子需要一个过程: 等待 3 秒
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 生产完成后,修改包子的状态为 true
                baozi.flag = true;

                // 唤醒 吃货线程,让吃货线程 去吃包子
                baozi.notify();
                System.out.println("包子铺已经生产好了"+baozi.InSide+""+baozi.OutSide+"包子可以吃了");
            }
        }
    }
}

消费者

// 吃货类

/**
 消费者 吃货类,是一个线程类,
 设置线程任务 吃包子
 对包子的状态进行 判断
 true 有包子
 吃货吃包子
 吃完包子,修改包子的状态 false 没有包子
 吃货唤醒 包子铺的线程 生产包子

 false 没有包子
 吃货等待 调用 wait 方法,进入到等待状态
 */
public class Customer extends Thread{

    // 1.在成员的位置上定义一个包子变量
    private BaoZi baozi;

    // 2. 使用带参构造,为这个包子变量赋值
    public Customer(BaoZi baozi){
        this.baozi = baozi;
    }

    @Override
    public void run() {
        // 设置线程任务,吃包子
        // 使用死循环,让吃货一直吃包子
        while(true){
            // 使用线程同步技术
            synchronized (baozi){
                // 对包子的状态进行判断
                if(!baozi.flag){
                    // 让吃货线程进入等待
                    try {
                        baozi.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 被唤醒后执行吃包子
                System.out.println("吃货正在吃:" + baozi.OutSide + "" + baozi.InSide + "包子");
                // 吃完包子
                // 修改包子状态为 false 没有包子
                baozi.flag = false;
                // 吃货线程唤醒包子铺线程 --> 生产包子
                baozi.notify();
                System.out.println("吃货已经吃完 "+baozi.OutSide+baozi.InSide + " 包子");
                System.out.println("-----------------------------------------------");
            }
        }
    }
}

测试类

public class MainProgram {

    public static void main(String[] args) {

        // 创建 包子 对象
        BaoZi baozi = new BaoZi();

        // 创建 包子铺 线程对象
        new Producer(baozi).start();
        // 创建 吃货线程
        new Customer(baozi).start();

    }
}