08_3_线程间的通信和生产者消费者的实现

最新推荐文章于 2022-03-01 19:25:25 发布

惨猴

最新推荐文章于 2022-03-01 19:25:25 发布

阅读量135

点赞数

分类专栏： HeimaJava 文章标签： Java

本文链接：https://blog.csdn.net/qq_37696899/article/details/102961148

版权

HeimaJava 专栏收录该内容

41 篇文章 0 订阅

订阅专栏

线程间的通信

package com.itheima.demo08.WaitAndNotify;

/*
    等待唤醒案例:线程之间的通信
        创建一个顾客(消费者):告知老板要的包子的种类和数量,调用wait方法,放弃cpu的执行,进入到WATTING状态(无效等待状态)
        创建一个老板(生产者):花了5s做包子,做好包子后,调用notify方法,唤醒顾客吃包子

    注意:
        顾客和老板线程必须使用同步代码块包裹起来,保证等待和唤醒只能有一个在执行
        同步使用的锁对象必须保证唯一
        只有锁对象才能调用wait和notify方法
    void wait() 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。
    void notify() 唤醒正在等待对象监视器的单个线程。  会继续执行wait方法之后的方法
 */
public class Demo01WaitAndNotify {
    public static void main(String[] args) {
        //创建锁对象,保证唯一
        Object obj = new Object();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
                    synchronized (obj) {
                        obj.notify();
                        System.out.println("告知老板要的包子的种类和数量");
                        //调用wait方法,放弃cpu的执行,进入到WATTING状态(无效等待状态)
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子真香");
                        System.out.println("________________________________________");
                    }
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    //花5秒做包子
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
                    synchronized (obj) {
                        System.out.println("花了5s做包子,做好包子后,告知顾客,可以吃包子了");
                        obj.notify();
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }).start();
    }
}
/*
    告知老板要的包子的种类和数量
    花了5s做包子,做好包子后,告知顾客,可以吃包子了
    包子真香
    ________________________________________
    告知老板要的包子的种类和数量
    花了5s做包子,做好包子后,告知顾客,可以吃包子了
    包子真香
*/

生产者消费者实现


package com.itheima.demo09.生产者消费者实现;

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




package com.itheima.demo09.生产者消费者实现;

/*
    生产者(包子铺)类:是一个线程类,可以继承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) {
                    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.xian + "的包子");
                //生产包子需要3秒钟
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //包子铺生产好包子后
                //修改包子的状态为true
                bz.flag = true;
                //唤醒吃货线程,让吃货线程吃包子
                bz.notify();
                System.out.println("包子铺已经生产好了" + bz.xian + " 包子,吃货可以开始吃了");
            }
        }
    }
}




package com.itheima.demo09.生产者消费者实现;

/*
    消费者(吃货)类:是一个线程类,可以继承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 {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //被唤醒之后执行的代码,吃包子
                System.out.println("吃货正在吃" + bz.xian + "包子");
                //吃完包子,修改包子状态
                bz.flag = false;
                //唤醒包子铺线程
                bz.notify();
                System.out.println("吃货已经把" + bz.xian + "包子吃完了,包子铺开始生产包子了");
                System.out.println("_________________________________________________________________");
            }
        }
    }
}




package com.itheima.demo09.生产者消费者实现;
/*
    测试类:
        包含main方法
        创建包子对象
        创建包子铺线程,开启,生产包子
        创建吃货线程,开启,吃包子
 */
public class Demo {
    public static void main(String[] args) {
        //创建包子对象
        BaoZi bz = new BaoZi();
        //创建包子铺线程,开启,生产包子
        new BaoZiPu(bz).start();
        //创建吃货线程,开启,吃包子
        new ChiHuo(bz).start();
    }
}