Day20：线程之间的通信-----生产者消费者

最新推荐文章于 2022-06-12 17:11:03 发布
最新推荐文章于 2022-06-12 17:11:03 发布
阅读量156 收藏
点赞数
分类专栏： Java
一切都来得及！共同进步！
本文链接：https://blog.youkuaiyun.com/qq_34971756/article/details/90413247
版权
博客围绕生产者 - 消费者线程模型展开，介绍了一个生产者与一个消费者、多个生产者与多个消费者的情况。以产品类为例，分五步实现生产一个消费一个的效果，还阐述了‘生产者 - 消费者 - 仓储’模型，明确生产者、消费者在仓储不同状态下的行为。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

案例一：有两个线程，一个生产者线程，一个消费者线程

假设有一个产品类(实体类)，我们通过生产者线程对其值（属性）进行设置，通过消费者线程再读取其设置的值。

要达到的最终效果是：每次生产一个，消费一个。

分五步来实现：

第一步，两个线程正确操作同一个数据源

第二步，采用循环实现数据的交替变化（数据在两个产品之间切换），来更明显发现上述程序存在的问题（把潜在问题放大化）

第三步，采用同步机制来解决上述的问题

第四步，考虑如何达到读一个写一个的效果（java的等待唤醒机制 wait notiy）

生产一个消费一个

生产者，发现有产品，就休息一下，等待消费者消费，等消费完，继续生产

消费者，发现没有产品，就休息以下，等待生产者进行生产，生产完了，继续消费

 

第五步，更加合理的优化写法

把原先是否需要wait()的控制由生产者线程（或消费者线程）搬到了产品类里面的同步方法中，调用者只管调用，不需要关注同步的处理细节，就好比下面的理解来看

生产者（厨师）

产品类（服务员-手握决定权）

消费者（顾客）

 

一个生产者一个消费者

public class Test01 {

	public static void main(String[] args) {
		
		Phone phone = new Phone();
		Producer producer = new Producer(phone);
		Consumer consumer = new Consumer(phone);
		
		producer.start();
		consumer.start();	
	}
}

//手机类
public class Phone {
	private String brand;
	private double price;
	private boolean store;
	
	public Phone() {}
	public Phone(String brand, int price) {
		this.brand = brand;
		this.price = price;
	}
	
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	
	public double getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
	
	public boolean isStore() {
		return store;
	}
	public void setStore(boolean store) {
		this.store = store;
	}
}

//生产者线程
public class Producer extends Thread{
	private Phone phone;
	public Producer(Phone phone) {
		this.phone = phone;
	}
	@Override//重写run方法
	public void run() {
		boolean flag=true;
		while(true) {
			synchronized (phone) {
				if(phone.isStore()==true) {
					try {
						phone.wait();
					} catch (InterruptedException e) {}
				}
				if(flag) {
					phone.setBrand("三星");
					phone.setPrice(4999);
				}else {
					phone.setBrand("小米");
					phone.setPrice(1999);
				}
				flag=!flag;
				phone.setStore(true);
				phone.notify();
			}
		}
	}
}

//消费者线程
public class Consumer extends Thread{
	private Phone phone;
	public Consumer(Phone phone) {
		this.phone = phone;
	}
	@Override
	public void run() {
		while(true) {
			synchronized (phone) {
				if(phone.isStore()==false) {
					try {
						phone.wait();
					} catch (InterruptedException e) {}
				}
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {}
				System.out.println(phone.getBrand()+"---"+phone.getPrice());
				phone.setStore(false);
				phone.notify();
			}
		}
	}
}

多个生产者多个消费者

public class Test01 {

	public static void main(String[] args) {
		
		Phone phone = new Phone();
		Producer producer1 = new Producer(phone);
		Producer producer2 = new Producer(phone);
		Consumer consumer1 = new Consumer(phone);
		Consumer consumer2 = new Consumer(phone);
		
		producer1.start();
		producer2.start();
		consumer1.start();
		consumer2.start();
		
	}
}

//手机类
public class Phone {
	private String brand;
	private double price;
	private boolean store;
	
	public Phone() {

	}
	public Phone(String brand, int price) {
		this.brand = brand;
		this.price = price;
	}

	public String getBrand() {
		return brand;}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	
	public double getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
	
	public boolean isStore() {
		return store;
	}
	public void setStore(boolean store) {
		this.store = store;
	}
}

//生产者
public class Producer extends Thread{
	private Phone phone;
	public Producer(Phone phone) {
		this.phone = phone;
	}
	@Override
	public void run() {
		boolean flag=true;
		while(true) {
			synchronized (phone) {
				while(phone.isStore()==true) {
					try {
						phone.wait();
					} catch (InterruptedException e) {
						// TODO 自动生成的 catch 块
						e.printStackTrace();
					}
				}
				if(flag) {
					phone.setBrand("三星");
					phone.setPrice(4999);
				}else {
					phone.setBrand("小米");
					phone.setPrice(1999);
				}
				flag=!flag;
				phone.setStore(true);
				phone.notifyAll();
			}
		}
	}
}

//消费者
public class Consumer extends Thread{
	private Phone phone;
	public Consumer(Phone phone) {
		this.phone = phone;
	}
	@Override
	public void run() {
		while(true) {
			synchronized (phone) {
				while(phone.isStore()==false) {
					try {
						phone.wait();
					} catch (InterruptedException e) {
						// TODO 自动生成的 catch 块
						e.printStackTrace();
					}
				}
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO 自动生成的 catch 块
					e.printStackTrace();
				}
				System.out.println(phone.getBrand()+"---"+phone.getPrice());
				phone.setStore(false);
				phone.notifyAll();
			}
			
		}
	}
}

  1. 案例二：

实际上，准确说应该是“生产者-消费者-仓储”模型，离开了仓储，生产者消费者模型就显得没有说服力了。
对于此模型，应该明确一下几点：
1、生产者仅仅在仓储未满时候生产，仓满则停止生产。
2、消费者仅仅在仓储有产品时候才能消费，仓空则等待。
3、当消费者发现仓储没产品可消费时候会通知生产者生产。
4、生产者在生产出可消费产品时候，应该通知等待的消费者去消费。

生产者消费者仓储模式

public class Test01 {

	public static void main(String[] args) {
		//生产者-仓储-消费者
		Store store = new Store();
		Producer producer = new Producer(store);
		Consumer consumer = new Consumer(store);
		
		producer.start();
		consumer.start();	
	}
}

//仓储
public class Store {

	private int max = 20;//最大容量
	private int num = 0;//最小容量
	//入库
	public void push() {
		synchronized (this) {
			if(num>=max) {
				try {
					this.wait();
				} catch (InterruptedException e) {
				}
			}
			num++;
			System.out.println("入库"+num);
			this.notify();
		}
	}



	//出库
	public void pop() {
		synchronized (this) {
			if(num<=0) {
				try {
					this.wait();
				} catch (InterruptedException e) {
				}
			}
			num--;
			System.out.println("出库："+num);
			this.notify();
		}
	}



}


//生产者
public class Producer extends Thread{
	private Store store;

	public Producer(Store store) {
		this.store=store;
	}
	@Override
	public void run() {
		while(true) {
			store.push();
		}
	}

}

//消费者
public class Consumer extends Thread{
	private Store store;

	public Consumer(Store store) {
		this.store = store;
	}
	@Override
	public void run() {
		while(true) {
			store.pop();
		}
	}
}

卖包子模型-LinkedList先进先出

public class Test01 {

	public static void main(String[] args) {
		
		Store store = new Store();
		Producer producer1 = new Producer(store);
		Producer producer2 = new Producer(store);
		Producer producer3 = new Producer(store);
		Consumer consumer1 = new Consumer(store);
		Consumer consumer2 = new Consumer(store);
		Consumer consumer3 = new Consumer(store);
		Consumer consumer4 = new Consumer(store);
		Consumer consumer5 = new Consumer(store);
		Consumer consumer6 = new Consumer(store);
		
		producer1.start();
		producer2.start();
		producer3.start();
		consumer1.start();
		consumer2.start();
		consumer3.start();
		consumer4.start();
		consumer5.start();
		consumer6.start();
		
	}
}

包子类
public class BaoZi {
	private String time;
	public BaoZi() {}
	public BaoZi(String time) {
		this.time = time;
	}
	/**
	 * @return time
	 */
	public String getTime() {
		return time;
	}
	/**
	 * @param time 要设置的 time
	 */
	public void setTime(String time) {
		this.time = time;
	}
	/* （非 Javadoc）
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return "包子日期" + time;
	}
	
}

仓储
public class Store {

	private int max = 20;//最大容量
	private int num = 0;//最小容量
	private LinkedList<BaoZi>  list = new LinkedList<>();
	//入库
	public void push() {
		synchronized (this) {
			while(num>=max) {
				try {
					this.wait();
				} catch (InterruptedException e) {
				}
			}
			num++;
			System.out.println("入库"+num);
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy MM dd HH:mm:ss");
			String time = sdf.format(new Date());
			BaoZi baoZi = new BaoZi(time);
			list.add(baoZi);
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
			this.notifyAll();
		}
	}



	//出库
	public void pop() {
		synchronized (this) {
			while(num<=0) {
				try {
					this.wait();
				} catch (InterruptedException e) {
				}
			}
			num--;
			System.out.println("出库："+num+list.removeFirst());
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
			this.notifyAll();
		}
	}



}

生产者
public class Producer extends Thread{
	private Store store;

	public Producer(Store store) {
		this.store=store;
	}
	@Override
	public void run() {
		while(true) {
			store.push();
		}
	}

}

消费者
public class Consumer extends Thread{
	private Store store;

	public Consumer(Store store) {
		this.store = store;
	}
	@Override
	public void run() {
		while(true) {
			store.pop();
		}
	}
}

 

Java自学习day19-线程通信的应用：经典例题：生产者/消费者问题
加油鸭
05-16 178
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。 分析： * 1. 是否是多线程问题？是，生产者线程，消费者线程 * 2. 是否有共享数据？是，店员（或产品） * 3. 如何解决线程的安全问题？同步机制,有三种方法 * 4
day18+day19:java多线程
卓汶的博客
11-06 778
多线程 1、基本概念：程序、进程、线程的理解 程序( program) 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码,静态对象。 进程( process) 是程序的一次执行过程,或是正在运行的一个程序。是一个动态的过程:有它自身的正生、存在和消亡的过程。——生命周期 如:运行中的QQ,运行中的MP3播放器 程序是静态的,进程是动态的 进程作为资源分配的单位,系统在运行时会为每个进程分配不同的内存区域 线程( thread) ,进程可进一步细化为线程,是一个程序内部的一条执行路
Java线程间的通信----生产者消费者模型
11-26
利用线程间的通信主要是因为当多个线程同时对一个对象进行访问的时候，多个线程之间是一个协助的关系，举个例子就是今天要说的生产这和消费者模型。
线程通信之生产者消费者模型
李章勇的博客
01-29 246
线程通信之生产者消费者模型 　　线程通信，是指线程之间的消息传递。 　　多个线程在操作同一个资源时，它们对共享资源的操作动作可能不同；它们共享同一个资源，互为条件，相互依赖，相互通信，从而让任务向前推进。 　　另外，在线程的同步策略中，虽然可以解决并发更新同一个资源，保障资源的安全，但不能用来实现线程间的消息传递。因此，线程通信与线程同步往往会融合...
线程通信_生产者消费者
、YongTing
03-22 240
参考：https://www.cnblogs.com/Wenxu/p/7979023.html 举例生产消费面包 面包的类 public class Breads { //面包的id private int bid; //面包的个数 private int num; //生产面包的方法（由于是demo，方便大家理解，就把sy...
JAVA基础 线程间的通信
淡若清风
12-24 138
线程间的通信 案例： 生产者生成水果，如果水果没有被买走那么就不生产，处于等待状态，如果水果被消费者买走这时候消费者就会通知生产者，告诉他我们已经把水果买走了请重新生产。 消费者同理，如果水果已经生产出来那么就买走，买走了之后通知生产者水果已经没有了，请生产。 注意: 1.线程间的通讯共享数据一定要有同步代码块 synchronized 2.一定要有wait和notify，而且二者一定是成对出现。 3.生产者和消费者的线程实现一定是在white(true)里面 第一种方式 继承 Thread 创建篮子
线程通信（生产者和消费者）
wt5264的博客
11-16 1478
1.分析 这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，有需要马上通知消费者消费 对于消费者，消费完之后，要通知生产者已经结束消费，需要生产新的产品以供消费 生产者消费者问题中，仅有synchronized是不够的 synchronized可阻止并发更新同一个共享资源，实现了同步 synchronized不能用来实现不同线程之纪检的消息传递 2.线程通信提供的方法 方法名
头歌java多线程基础-day11.rar
最新发布
12-02
线程池是一种基于生产者-消费者模式的资源池技术，用于管理线程的生命周期和执行，提高了程序的性能和资源利用率。并发集合如ConcurrentHashMap和AtomicInteger等则是专门为了多线程环境而设计的集合类和原子操作类...
嵌入式实习-day5-线程
11-20
- 多个信号量组合使用时，可以实现更复杂的同步策略，例如生产者-消费者模型中的同步控制。 #### 示例题目解答： - **题目一**：只有一个信号量，能够实现什么功能，并写代码验证 一个信号量可以用来实现资源的...
Day 22多线程、线程通信、线程池和Lambda表达式
12-22
例如，生产者消费者模型中，生产者线程和消费者线程通过共享数据结构（如队列）来交互，生产者生产商品放入队列，消费者从队列中取出商品。为了保证数据的一致性，通常需要使用`wait()`和`notify()`进行同步控制，...
线程通信(生产者,消费者模式)
五谷丰登
07-30 196
测试类 public class Test { public static void main(String[] args) { // TODO Auto-generated method stub Goods goods = new Goods(); Producer producer = new Producer(goods);//Producer类中的构造方法必须传参 //创建多线程...
【线程通信】生产者-消费者模式
ChineseSoftware的博客
05-06 873
一、简述 1️⃣生产者消费者模式并不是 GOF 提出的 23 种设计模式之一，23 种设计模式都是建立在面向对象的基础之上的，但其实面向过程的编程中也有很多高效的编程模式，生产者消费者模式便是其中之一，它是编程过程中最常用的一种设计模式。 一个常见的场景：某个模块负责产生数据，这些数据由另一个模块来负责处理(此处的模块是广义的，可以是类、函数、线程、进程等)。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。单单抽象出生产者和消费者，还够不上是生产者/消费者模式。该模式还需要有一个缓冲区处
线程之间的通信(生产者和消费者问题)
m0_37989524的博客
10-18 455
消费者线程:package cn.org.lin.cp; public class Customer implements Runnable{ //仓库中 ShareData sd ; public Customer(ShareData sd) { this.sd = sd; } public ShareData getSd() { r
线程通信之生产者消费者详解
蜜蜂采蜜
06-19 688
先前我们讲解了多线程互斥访问同一资源问题，接下来我们讲解一下线程通信问题之经典：生产者与消费者 线程通信：不同的线程在执行不同的任务，如果这些任务的执行之间存在先后顺序，那么线程之间必须要能够通信，协调的完成工作。 （一）经典案例： （1）生产者和消费者等多个线程在访问共同资源时， 必须要互斥（即要访问的临界资源一样），只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以
线程通信--生产者消费者问题
niceYF的博客
03-28 451
解决方法1–管程法 生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
线程通信-生产者消费者模式
weixin_44164943的博客
04-08 149
什么是生产者消费者模式 生产者与消费者模式就是一个多线程并发协作的模式，在这个模式中，有的线程处理数据而产生的结果集是另一部分线程所需处理的数据源，于是便有了形象的生产者与消费者了。这里的生产者便是产生结果集的线程，消费者就是对结果集进行再处理的线程。而为了更好的优化生产者与消费者的关系，便设立一个缓冲区，也就相当于一个数据仓库，当生产者生产数据时锁住仓库，不让消费者访问，当消费者消费时锁住仓库，不让生产者访问仓库。 下面是java代码实现 /** * 生产者消费者模型--> 利用缓冲区解决：管程法
线程通信-生产者消费者问题
dayuiicghaid的博客
06-12 322
生产者消费者问题： 1、假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库﹐消费者将仓库中产品取走消费． 2、如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待﹐直到仓库中的产品被消费者取走为止. 3、如果仓库中放有产品﹐则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止．这是一个线程同步问题,生产者和消费者共享同一个资源（产品），并且生产者和消费者之间相互依赖，互为条件． 对于生产者﹐没有生产产品之前，要通知消费者寺待﹒而生广J广加口，人需要马上通知消费者消费
线程间通信(生产者消费者问题)
sxb956347789的博客
10-23 492
一、多线程通过把任务分成离散的和合乎逻辑的单元代替了事件循环程序。二、它远离了轮询。轮询通常由重复监测条件的循环实现。一旦条件成立，就要采取适当的行动。这浪费了CPU时间。举例来说，考虑经典的序列问题，当一个线程正在产生数据而另一个程序正在消费它。为使问题变得更有趣，假设数据产生器必须等待消费者完成工作才能产生新的数据。在轮询系统，消费者在等待生产者产生数据时会浪费很多CPU周期。一旦生产者完成工
线程间通信-生产者消费者模型
爱琴孩的博客
11-28 278
前言 所谓的线程间通信，其实就是多个线程再操作同一个资源，但是操作的动作不同。当某个线程进入synchronized块后，共享数据的状态不一定满足该线程的需要，需要其他线程改变共享数据的状态后才能运行，而由于当时线程对共享资源时独占的，它必须解除对共享资源的锁定的状态，通知其他线程可以使用该共享资源。 wait()和notify() 线程之间的通信其实可以通过很多方法来实现，比如wait()...
每日挑战Codewars: A-Kata-A-Day实践记录
资源摘要信息:"A-Kata-A-Day:每天从Codewars解决一个Kata" 知识点概述： 1. Kata概念：Kata在编程领域是一种编程练习，通常由一系列小问题构成，用来提高编程技能和算法理解。 2. Codewars平台：Codewars是一个在线...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值