【等待唤醒机制】1.以包子铺生产包子,吃货吃包子为例子 2.synchronized+wait+notify

已于 2022-11-17 15:06:35 修改
阅读量438 收藏 2
点赞数
分类专栏： # java多线程 文章标签： java rabbitmq
于 2020-02-20 17:01:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/themagickeyjianan/article/details/104413739
版权 
1)线程的6种状态
	NEW(新建状态): 至今尚未启动的线程处于这种状态.

	RUNNABLE(运行状态): 正在java虚拟机中执行的线程处于这种状态.

	BLOCKED(阻塞状态): 受阻塞并等待某个监视器锁的线程处于这种状态.
		等待CPU资源,有则可能执行;
		start后开始争夺CPU的执行资源,没有抢到就进入到阻塞状态;
			获取到锁对象,就进入到运行状态;

	WAITING(无限永久等待状态): 无限期的等待另一个线程来执行某一特定操作的线程处于这种状态.
		冻结状态;

	TIMED_WAITING(休眠(睡眠状态)): 等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态.
		睡眠,能睡醒,睡醒后,有CPU资源,则执行。 睡眠时,CPU空着也不能执行,必须等待睡醒后;
		也是冻结状态;

	TERMIANTED(死亡状态): 已退出的线程处于这种状态.

2)等待唤醒的案例(也叫线程之间的通信)
	卖包子的商铺:
		消费者
		生产者

	描述: 
		顾客要买包子,和老板说明买包子的数量和种类;
			顾客: 等着老板做包子(调用wait方法-->WAITING状态,无限等待).
			老板: 开始做包子,做好包子,告诉(调用notify方法),顾客包子做好了,就可以开吃了.
			顾客和老板之间形成了一种通信.

3)实现
	创建一个顾客线程(消费者): 告知老板要的包子的种类和数量,调用wait方法,放弃CPU的执行,进入到WAITING状态(无限等待);

	创建一个老板线程(生产者): 花了5s做包子,做好包子之后,调用notify方法,唤醒顾客吃包子;

	注意:
		顾客和老板线程必须使用同步代码块包裹起来,保证等待和唤醒只能有一个在执行.
		同步使用的锁对象必须保证唯一.
		只有锁对象才能调用wait和notify方法.

4)Object的方法
	void wait(): 
	  在其它线程调用此对象和notify方法或notifyall方法前,导致当前线程等待.

	void notify(): 
	  唤醒在此对象监视器上等待的单个线程. 
	  会继续执行wait方法之后的代码.

	  有多个等待的线程的话,会随机唤醒一个;

	wait(long m): 
		在m毫秒结束后,还没有被notify唤醒,就会自动醒来;
		和sleep方法是一样的;

	void notifyAll():
		唤醒在此对象监视器上等待的所有线程;

		唤醒所有等待的线程;

5)等待唤醒机制(线程间通信):
	吃包子和做包子之间的协调: 
		不能吃的时候,还没做出来.
		不能做出来,没人吃.

6)通信: 对包子的状态进行判断
	没有包子-->吃货线程唤醒包子线程-->吃货线程等待-->包子铺线程做包子-->做好包子-->修改包子状态为有;
	有包子-->包子铺线程唤醒吃货线程-->包子铺线程等待-->吃货吃包子-->吃完包子-->修改包子的状态为没有;

	重点是利用好包子状态;

7) 任何对象都可以成为锁对象;

8)wait方法与notify方法必须要在同步代码块或者是同步函数中使用,因为:必须要通过锁对象调用这2个方法,保证了锁的唯一性;

9)分析:需要哪些类?(生产者消费者问题)
	1.资源类: 包子类
		设置包子的属性:
			皮
			馅
			包子的状态: 有true 没有false

	2.生产者(包子铺): 是一个线程类,可以继承Thread
		设置线程任务(run): 生成包子
		对包子的状态进行判断
		true: 有包子
			包子铺调用wait方法进入等待状态
		false: 没有包子
			增加一些趣味性,交替生产2种包子(i%2==0)
			包子铺线程生产好了包子
			修改包子的状态为true
			唤醒吃货线程,让吃货线程池包子

	3.消费者(吃货), 也是一个线程类,可以继承Thread
		设置线程任务(run): 吃包子
		对包子的状态进行判断
		false:没有包子
			吃货线程调用wait方法进入等待状态
		true:有包子
			吃货吃包子
			吃货吃完包子
			修改包子的状态为false没有
			吃货 唤醒 包子铺线程,生产包子

	4.测试类:
		包含main方法,程序执行的入口,启动程序;
		创建包子对象;
		创建包子铺线程,开启;
		创建吃货线程开启;

	注意: 
		包子铺线程和吃货线程的关系-->通信(互斥)
	    必须用同步技术保证2个线程只有一个在执行
		锁对象必须保证唯一,可以使用包子对象作为锁对象
		包子铺类和吃货类就需要把包子对象作为参数传递进去
			1.需要在成员位置创建一个包子变量
			2.使用带参数构造方法,为这个包子变量赋值

BaoZI.java // 包子

package com.itcast.thread07.demo01;

public class BaoZI {
    String pi;
    String xian;
    boolean flag = false; // 是否生产好了
}

BaoZiPu.java // 包子铺

package com.itcast.thread07.demo01;

public class BaoZiPu extends Thread {
    private BaoZI bz;

    public BaoZiPu(BaoZI bz) {
        this.bz = bz;
    }

    @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.pi + " " + bz.xian + " 包子");

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                bz.flag = true;
                bz.notify();
                System.out.println("包子铺已经生产好了" + bz.pi + " " + bz.xian + " 包子,吃货可以开吃了");
            }
        }
    }
}

ChiHuo

package com.itcast.thread07.demo01;

public class ChiHuo extends Thread {
    private BaoZI bz;

    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.pi + " " + bz.xian + " 的包子");
                bz.flag = false;
                bz.notify();
                System.out.println("吃货把" + bz.pi + " " + bz.xian + " 的包子吃完了!\n");
            }
        }
    }
}

Demo

package com.itcast.thread07.demo01;

public class Demo {
    public static void main(String[] args) {
        BaoZI bz = new BaoZI();
        ChiHuo ch = new ChiHuo(bz);
        BaoZiPu bzp = new BaoZiPu(bz);

        ch.start();
        bzp.start();
    }
}

包子铺正在生产薄皮 三鲜 包子
包子铺已经生产好了薄皮 三鲜 包子,吃货可以开吃了
吃货正在吃薄皮 三鲜 的包子
吃货把薄皮 三鲜 的包子吃完了!

包子铺正在生产冰皮 大葱 包子
包子铺已经生产好了冰皮 大葱 包子,吃货可以开吃了
吃货正在吃冰皮 大葱 的包子
吃货把冰皮 大葱 的包子吃完了!

包子铺正在生产薄皮 三鲜 包子
包子铺已经生产好了薄皮 三鲜 包子,吃货可以开吃了
吃货正在吃薄皮 三鲜 的包子
吃货把薄皮 三鲜 的包子吃完了!

包子铺正在生产冰皮 大葱 包子
包子铺已经生产好了冰皮 大葱 包子,吃货可以开吃了
吃货正在吃冰皮 大葱 的包子
吃货把冰皮 大葱 的包子吃完了!

包子铺正在生产薄皮 三鲜 包子
包子铺已经生产好了薄皮 三鲜 包子,吃货可以开吃了
吃货正在吃薄皮 三鲜 的包子
吃货把薄皮 三鲜 的包子吃完了!

包子铺正在生产冰皮 大葱 包子
包子铺已经生产好了冰皮 大葱 包子,吃货可以开吃了
吃货正在吃冰皮 大葱 的包子
吃货把冰皮 大葱 的包子吃完了!

包子铺正在生产薄皮 三鲜 包子

Process finished with exit code -1

.net core game
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java学习笔记】多线程的等待唤醒机制案例——做包子吃包子
delpaction的专栏
07-24 464
【Java学习笔记】多线程的等待唤醒机制案例——做包子吃包子 为了实现线程的等待（wait）与唤醒（notify），我参考教学视频模拟了一个经典的案例。 明确这个例子中有一个资源类与两个需要通信的线程类：包子（资源），包子店（线程A），顾客（线程B） 首先是包子类： //包子是资源类，同时作为同步代码块的锁对象进行传递 public class BaoZi { //包子的种类，字符串类型 private String typeOfBaoZi; //是否还有包子，布尔类型，设置一个初始
Java练习>等待唤醒机制实现>>吃货吃包子案例
越努力，越幸福！
08-09 437
案例： 定义包子类： package XianCheng.ChiHuo; /* 资源类：包子类 设置包子的属性 皮 陷 包子的状态：有 true，没有 false */ public class BaoZi { //皮 String pi; //陷 String xian; //包子的...
Java多线程_生产者消费者_包子铺_多生产多消费问题
qq_40739476的博客
11-26 416
Java多线程、生产者消费者、多生产多消费、包子铺
Java多线程中的生产者与消费者问题：等待唤醒机制的应用：wait()和notify()
m0_43410048的博客
05-04 238
等待唤醒机制其实就是经典的“生产者与消费者”的问题。 就拿生产包子消费包子来说等待唤醒机制如何有效利用资源： 包子铺线程生产包子，吃货线程消费包子。当包子没有时（包子状态为false），吃货线程等待，包子铺线程生产包子（即包子状态为true），并通知吃货线程（解除吃货的等待状态）,因为已经有包子了，那么包子铺线程进入等待状态。接下来，吃货线程能否进一步执行则取决于锁的获取情况。如果吃货获取到锁，那...
多线程（四） 线程状态 案例：包子铺卖包子
qq_35670694的博客
04-20 1302
线程状态概述 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中， 有几种状态呢？在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态： 这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析 我们不需要去研究这几种状态的实现原理，我们只需知道在做线程操作中存在这样的状态。那我们怎么去理解...
3.等待唤醒机制
你好啊cbw
01-30 333
3.等待唤醒机制
Object.wait()与Object.notify()的用法详细解析
09-05
一个线程调用`wait()`进入等待状态，其他线程改变条件后调用`notify()`或`notifyAll()`来唤醒等待的线程。这种模式在生产者消费者问题、读写锁等多线程设计中非常常见。 总结一下，`Object.wait()`、`Object.notify...
Java多线程之线程通信生产者消费者模式及等待唤醒机制代码详解
08-29
Java多线程之线程通信生产者消费者模式及等待唤醒机制代码详解 该篇文章主要介绍了Java多线程之线程通信生产者消费者模式及等待唤醒机制代码详解，通过对生产者消费者模式的编程实现和等待唤醒机制的应用，阐述了多...
27_多线程_第2天（线程安全、线程同步、等待唤醒机制、单例设计模式）_讲义
02-16
然而，多线程环境下也会带来一系列问题，如数据不一致性、资源竞争等，因此，理解线程安全、线程同步以及等待唤醒机制至关重要。此外，单例设计模式在确保一个类只有一个实例的同时，提供了全局访问点，也是多线程...
详解Java程序并发的Wait-Notify机制
09-03
1. `wait()`, `notify()`, `notifyAll()`必须在`synchronized`代码块或方法中调用，以确保线程安全。 2. 调用`wait()`后，线程会释放对象锁，等待被唤醒。当线程被唤醒后，需要重新获取锁才能继续执行。 3. `notify...
等待唤醒机制包子铺案例
xxxjackboy的博客
11-14 111
1.1线程间通信 概念：多个线程在处理同一个资源，处理的动作（任务）不同 1.2等待唤醒案例 代码实现 /* 资源类：包子类 设置包子的属性： 皮、馅、包子的状态：有true，没有false */ public class BaoZi { //皮 String pi; //馅 String xian; //状态，初始为false boolean flag = false; } /* 包子铺：线程类，继承Thread 设置线程任务run；生产包子 对包子的状态判断 true：调用wait方法进入等待状态
Java学习：线程间通信
菜鸟-传奇
08-04 128
线程间通信 概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同重点：有效的利用资源 分析：需要那些类 1 资源类：包子类 设置包子的属性 包子的状态：有true 没有false 2 生产者（包子铺）类：是一个线程类，可以继承Thread 设置线程任务（run):生产包子 对包子的状态进行判断 true:有包子 包子铺调用wait方法...
Java中多线程模拟包子铺造和 吃货吃包子
xilin6664的博客
03-31 1544
包子铺: import java.util.ArrayList; public class BaoZiPu implements Runnable { //定义变量:包子集合 ArrayList<String> baoZi; public BaoZiPu(ArrayList<String> baoZi) {//将包子集合作为构造方法的形参 ...
Java学习——等待与唤醒机制：生产者与消费者问题
weixin_44664432的博客
06-17 244
1.线程间通信 指的是多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。 那么为什么要去处理线程间通信呢？ 多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来【共同完成一件任务】，并且我们希望他们有【规律的执行】, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。 如何保证线程间通信有效利用资源： 多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就是多个线程在操作同一份数据时， 避免对同一共
多线程生产者消费者问题详解-附面试题大全【精】
debugEDM的博客
07-29 698
多线程 生产者与消费者(线程通信) 实现生产者和消费者案例(一) public class Resource { //定义布尔类型的成员,标志位,指示线程该做什么 //false没有,需要生产, true需要消费 boolean flag = false; int count ;//包子的计数器 } public class Product implements Runnable { //创建资源对象 Resource r = new Resource(); public void r
多线程间之包子问题,生产者与消费者
HarrisJayce的博客
12-11 379
包子类 public class BaoZi {// 包子 String OutSide; // 皮 String InSide; // 馅 boolean flag = false; // 默认 没有包子 } 生产者 // 包子铺 ,生产者,是一个线程类 /** 生产者 是一个线程类,继承 Thread类 设置线程的任务时 生产包子 true 有包子 包子铺调用 wait 方法 进入等待状态 false 没有包子 增加难度,交替生产两种包子 两种状态 ( i %
多线层之间的等待唤醒 （吃货在包子铺吃包子为案例）
weixin_43308935的博客
02-26 155
//首先创建包子类，给其两个属性 和一个状态 （有/无） package day09; public class BaoZi { //两个属性，皮 String pi; //馅 String xian; //包子的状态 boolean zhuangTai=false; } package day09; public class BaoZiPu extends Thread { private Ba...
添加注释 public class Baozipu extends Thread{ private Baozi bz; public Baozipu(String name,Baozi bz){ super(name); this.bz=bz; } @Override public void run() { int count = 0; while(true){ synchronized (bz){ if(bz.flag==true) { try { bz.wait(); } catch (InterruptedException e) { throw new RuntimeException(e); } } System.out.println("没有包子，包子铺造包子"); if(count % 2 == 0){ bz.pier="冰皮"; bz.xianer="五仁"; } else { bz.pier="薄皮"; bz.xianer="牛肉大葱"; } count++; bz.flag=true; System.out.println("包子造好了："+bz.pier+bz.xianer); System.out.println("吃货来吃吧"); //唤醒等待线程 （吃货） bz.notify(); } } } }
最新发布
06-07
/** * 包子铺线程类，继承自Thread类 */ public class Baozipu extends Thread{ private Baozi bz; //包子类对象 /** * 构造方法，用于传递包子对象和线程名... //唤醒等待线程（吃货） bz.notify(); } } } }

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值