等待唤醒机制案例分析

等待唤醒机制需求分析

资源类：

包子类
设置包子的属性
皮
馅
包子的状态：有true，没有false

package com.Thread.WaitAndNotify;

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

生产者（包子铺）类：是一个线程类，可以继承Thread
设置线程任务（run):生产包子

对包子的状态进行判断
true:有包子
包子铺调用wait方法进入等待状态
false:没有包子
包子铺生产包子
增加一些趣味性：交替生产两种包子
有两种状态（i%2==0)

包子铺生产好了包子
修改包子的状态为true有
唤醒吃货线程，让吃货线程吃包子

package com.Thread.WaitAndNotify;
/*
       生产者（包子铺）类：是一个线程类，可以继承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==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(3000);
                } 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 com.Thread.WaitAndNotify;
 /*
消费者（吃货）类：是一个线程类，可以继承Thread

设置线程任务（run)：吃包子

对包子的状态进行判断
false:没有包子
吃货线程调用wait方法进入等待状态
true:有包子

吃货吃包子
吃货吃完包子
修改包子的状态为false没有
吃货唤醒包子铺线程
  */
public class ChiHuo extends Thread{
     //1.需要在成员位置创建一个包子变量
     private BaoZi bz ;
     //2.使用带参数构造方法，为这个包子变量赋值
     public ChiHuo(BaoZi bz) {
         this.bz = bz;
     }
     @Override
     public void run() {
         //使用死循环让包子一直吃包子
         while (true){
             //必须同时同步技术保证两个线程只能一个在执行
             synchronized (bz){
                 //对包子的状态进行判断
                 if (bz.flag == false){
                     try {
                         //吃货线程调用wait方法进入等待状态
                         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("===================================");
             }
         }
     }
 }

测试类：

包含main方法，程序执行的入口，启动程序
创建包子对象；创建包子铺线程，开启，创建吃货线程开启

package com.Thread.WaitAndNotify;

import com.oop.demo06.B;

/*
     测试类：
     包含main方法，程序执行的入口，启动程序
     创建包子对象；创建包子铺线程，开启，创建吃货线程，开启
 */
public class Demo {
    public static void main(String[] args) {
        //创建包子对象
        BaoZi bz = new BaoZi();
        //创建包子铺线程,开启，生产包子
         new BaoZiPu(bz).start();
         //创建吃货线程，开启，吃包子
        new ChiHuo(bz).start();

    }
}

打印结果