生产者消费者模型+仓储模型及Java自带的线程池

最新推荐文章于 2023-01-10 21:50:01 发布
最新推荐文章于 2023-01-10 21:50:01 发布
阅读量368 收藏 1
点赞数
分类专栏： Java基础 文章标签： java 开发语言 学习 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GL280599ZL/article/details/127624921
版权

生产者消费者模型+仓储模型及Java自带的线程池

一、生产者消费者模型

1.注意：一个生产者一个消费者

2.最终目的：生产一个、消费一个

3.分析：

1.产品类 – Phone

2.生产者线程 – Producer

3.消费者线程 – Consumer

4.步骤：

步骤1：生产者线程和消费者线程操作同一个资源

步骤2：在两个产品之间切换（目的：将步骤1的问题扩大化）

步骤3：如何生产一个消费一个？

public class Test01 {

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

//消费者线程
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()) {//没有库存
					try{
						//等待
						phone.wait();
					}catch (InterruptedException e){
						e.printStackTrace();
					}
				}
				System.out.println(phone.getBrand() + " -- " + phone.getPrice());
				phone.setStore(false);
				
				//唤醒
				phone.notify();
			}
		}
	}
}

public class Phone {

	private String brand;
	private double price;
	private boolean isStore;
	
	public Phone() {
	}

	public Phone(String brand, double 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(double price) {
		this.price = price;
	}

	
	public boolean isStore() {
		return isStore;
	}

	public void setStore(boolean isStore) {
		this.isStore = isStore;
	}

	@Override
	public String toString() {
		return "Phone [brand=" + brand + ", price=" + price + "]";
	}	
}

//生产者线程
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) {
				if (phone.isStore()) {//有库存
					
					try{
						//等待(1.当前线程进入到阻塞状态 2.将当前线程记录在对象监视器中 3.释放锁资源)
						phone.wait();
					}catch(InterruptedException e){
						e.printStackTrace();
					}
				}
				if (flag) {
					phone.setBrand("华为");
					phone.setPrice(3999);
				} else {
					phone.setBrand("小米");
					phone.setPrice(1999);
				}
				phone.setStore(true);
				flag = !flag;
				
				//唤醒（对象监视器中可能记录了很多等待的线程，这里唤醒的是随机一个线程）
				phone.notify();
			}
			
		}
	}
	
}

5.多个生产者多个消费者的情况

if变为while

notify() 变为 notifyAll()

public class Test01 {

	public static void main(String[] args) {
		
		Phone phone = new Phone();
		
		Producer p1 = new Producer(phone);
		Producer p2 = new Producer(phone);
		
		Consumer c1 = new Consumer(phone);
		Consumer c2 = new Consumer(phone);
		
		p1.start();
		p2.start();
		c1.start();
		c2.start();
	}
}

public class Phone {

	private String brand;
	private double price;
	private boolean isStore;
	
	public Phone() {
	}

	public Phone(String brand, double 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(double price) {
		this.price = price;
	}

	public boolean isStore() {
		return isStore;
	}

	public void setStore(boolean isStore) {
		this.isStore = isStore;
	}

	@Override
	public String toString() {
		return "Phone [brand=" + brand + ", price=" + price + "]";
	}	
}

//消费者线程
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()) {//没有库存
					try {
						//等待
						phone.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				System.out.println(phone.getBrand()+ " -- " + phone.getPrice());
				phone.setStore(false);
				
				//唤醒
				phone.notifyAll();
			}
		}
	}
}

//生产者线程
public class Producer extends Thread{

	private Phone phone;
	private static boolean flag = true;
	
	public Producer(Phone phone) {
		this.phone = phone;
	}
	
	@Override
	public void run() {


		while (true) {
			synchronized (phone) {
				while (phone.isStore()) {//有库存
					
					try {
						//等待(1.当前线程进入到阻塞状态 2.将当前线程记录在对象监视器中 3.释放锁资源)
						phone.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				if (flag) {
					phone.setBrand("华为");
					phone.setPrice(3999);
				}else {
					phone.setBrand("小米");
					phone.setPrice(1999);
				}
				phone.setStore(true);
				flag = !flag;
				
				//唤醒（对象监视器中可能记录了很多等待的线程，这里唤醒的是所有等待的线程）
				phone.notifyAll();
			}		
		}
	}
}

二、仓储模型

需求：生产者线程不断的生产蛋糕放入仓库，消费者不断的从仓库中买蛋糕，要求先生产的蛋糕先卖出(队列)

分析：

1.蛋糕类

2.仓库类

3.生产者线程类

4.消费者线程类

1.一个生产者一个消费者的情况

public class Test01 {

	public static void main(String[] args) {
		
		Store store = new Store();
		
		Producer p = new Producer(store);
		Consumer c = new Consumer(store);
		
		p.start();
		c.start();
	}
}


//蛋糕类
public class Cake {

	private String brand;
	private double price;
	private String dateTime;
	
	public Cake() {
	}

	public Cake(String brand, double price, String dateTime) {
		super();
		this.brand = brand;
		this.price = price;
		this.dateTime = dateTime;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	public String getDateTime() {
		return dateTime;
	}

	public void setDateTime(String dateTime) {
		this.dateTime = dateTime;
	}

	@Override
	public String toString() {
		return  brand + "\t" + price + "\t" + dateTime ;
	}		
}


import java.util.LinkedList;
//仓库类
public class Store {

	//面包容器
	private LinkedList<Cake> list;
	//当前面包容量
	private int curCapacity;
	//最大面包容量
	private static final int MAX_CAPACITY = 20;
	
	public Store() {
		 list = new LinkedList<>();
	} 
	
	//入库 -- 生产者线程去调用
	public synchronized void push(Cake cake){
		if (curCapacity == MAX_CAPACITY) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		curCapacity++;
		list.add(cake);
		System.out.println("入库，当前面包容量为：" + curCapacity);
		
		this.notify();
	}
	
	//出库 -- 消费者线程去调用
	public synchronized void pop(){
		if (curCapacity == 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		curCapacity--;
		Cake cake = list.removeFirst();
		System.out.println("出库，当前面包容量为：" + curCapacity + " -- " + cake);
		
		this.notify();
	}
}


import java.time.LocalDateTime;
//生产者线程
public class Producer extends Thread{

	private Store store;

	public Producer(Store store) {
		this.store = store;
	}
	
	@Override
	public void run() {
		while (true) {
			Cake cake = new  Cake("桃李面包", 4.5, LocalDateTime.now().toString());
			store.push(cake);
		}
	}
}


//消费者线程
public class Consumer extends Thread{

	private Store store;

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

2.多个生产者多个消费者的情况

public class Test01 {
	public static void main(String[] args) {
		
		Store store = new Store();
		
		Producer p1 = new Producer(store);
		Producer p2 = new Producer(store);
		Consumer c1 = new Consumer(store);
		Consumer c2 = new Consumer(store);
		
		p1.start();
		p2.start();
		c1.start();
		c2.start();
		
	}
}


//蛋糕类
public class Cake {
	
	private String brand;
	private double price;
	private String dateTime;
	
	public Cake() {
	}

	public Cake(String brand, double price, String dateTime) {
		this.brand = brand;
		this.price = price;
		this.dateTime = dateTime;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	public String getDateTime() {
		return dateTime;
	}

	public void setDateTime(String dateTime) {
		this.dateTime = dateTime;
	}

	@Override
	public String toString() {
		return brand + "\t" + price + "\t" + dateTime;
	}
}


import java.util.LinkedList;

//仓库类
public class Store {

	//面包容器
	private LinkedList<Cake> list;
	//当前面包容量
	private int curCapacity;
	//最大面包容量
	private static final int MAX_CAPACITY = 20;
	
	public Store() {
		list = new LinkedList<>();
	}
	
	//入库 -- 生产者线程去调用
	public synchronized void push(Cake cake){
		while(curCapacity == MAX_CAPACITY){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		curCapacity++;
		list.add(cake);
		System.out.println("入库，当前面包容量为：" + curCapacity);
		
		this.notifyAll();
	}
	
	//出库 -- 消费者线程去调用
	public synchronized void pop(){
		while(curCapacity == 0){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		curCapacity--;
		Cake cake = list.removeFirst();
		System.out.println("出库，当前面包容量为：" + curCapacity + " -- " + cake);
		
		this.notifyAll();
	}
}


import java.time.LocalDateTime;

//生产者线程
public class Producer extends Thread{
	
	private Store store;
	
	public Producer(Store store) {
		this.store = store;
	}

	@Override
	public void run() {
		while(true){
			Cake cake = new Cake("桃李面包", 4.5, LocalDateTime.now().toString());
			store.push(cake);
		}
	}
}


//消费者线程
public class Consumer extends Thread{
	
	private Store store;
	
	public Consumer(Store store) {
		this.store = store;
	}

	@Override
	public void run() {
		while(true){
			store.pop();
		}
	}
}

三、Java自带的线程池

使用Java自带的线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test01 {

	public static void main(String[] args) {
		//创建单个线程的线程池
		//ExecutorService pool = Executors.newSingleThreadExecutor();
		//创建指定个数线程的线程池
		//ExecutorService pool = Executors.newFixedThreadPool(5);
		//创建可缓存线程的线程池(该线程池中没有线程，有任务就创建线程，60s没有执行任务的线程认为是闲置线程，会被销毁掉
		ExecutorService pool = Executors.newCachedThreadPool();
		for (int i = 1; i <=1000; i++) {
			//创建任务
			Task task = new Task(i);
			//提交任务
			pool.execute(task);
		}
		//关闭线程池
		pool.shutdown();
	}
}


import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Test02 {

	public static void main(String[] args) {
		//创海可缓存线程的线程池(该线程池中没有线程，有任务就创建线程，60s没有执行任务的线程认为是闲置线程，会被销毁掉)
		ScheduledExecutorService pool = Executors.newScheduledThreadPool(10);
		
		for (int i = 1; i <=1000; i++) {
			//创建任务
			Task task = new Task(i);
			/**
			 * 提交任务
			 * 参数1：提交的任务对象
			 * 参数2：延迟时间
			 * 参数3：时间类型
			 */
			pool.schedule(task, 5L, TimeUnit.SECONDS);
		}
		//关闭线程池
		pool.shutdown();
	}
}



import java.time.LocalDateTime;

public class Task implements Runnable{
	//任务编号
	private int num;
	
	public Task(int num) {
		this.num = num;
	}


	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() + "-------" + num + "---" + LocalDateTime.now());
		
	}	
}
雨霖先森
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java实现生产者消费者商品问题
08-12
主方法main()在ProducersAndConsumers这里类里面，直接导入项目运行即可。这个程序是根据网上别人的分享进行过修改，修改的地方有，商品的循环添加方式，使用arraylist方式取代数组（只是在代码里面注释，去掉注释复原即可），随机抽取商品，代码有较详细的注释，详细见代码。
生产消费模型详解以及代码实现（Java）
weixin_64625868的博客
04-09 1167
生产消费模型（Java代码示例）
生产者消费者模式
qq_36432147的博客
08-06 77
一、生产者消费者模式主要有三部分组成：仓库，生产者、消费者 1.仓库 同步的方式，往仓库存、取产品；仓库满或者仓库空，用waiy/notify来阻塞线程 2.生产者 用构造方法实例变量，共享仓库 3.消费者 4.运行 结果 二、除了用wait/notify方法解决生产消费者问题，还有BlockingQueue阻塞队列方法 好处是：Block...
设计模式：生产者消费者模式
dghh81279的博客
08-30 529
在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。 为什么要使用生产者和消费者模式？ 在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大...
Day855.生产者-消费者模式 -Java 并发编程实战
最新发布
阿昌爱Java
01-10 643
Java 语言提供的线程池本身就是一种生产者 - 消费者模式的实现，但是线程池中的线程每次只能从任务队列中消费一个任务来执行，对于大部分并发场景这种策略都没有问题。但是有些场景还是需要自己来实现，例如需要批量执行以及分阶段提交的场景。生产者 - 消费者模式在分布式计算中的应用也非常广泛。在分布式场景下，你可以借助分布式消息队列（MQ）来实现生产者 - 消费者模式。MQ一种是点对点模型一种是发布订阅模型。
Java多线程 BlockingQueue实现生产者消费者模型详解
08-25
Java多线程BlockingQueue实现生产者消费者模型详解 Java多线程中，生产者消费者模型是非常重要的一种设计模式，它可以解决多线程之间的数据传输问题。在Java中，我们可以使用BlockingQueue来实现生产者消费者模型，...
Java实现简易生产者消费者模型过程解析
08-19
Java实现简易生产者消费者模型过程解析 一、概述 生产者消费者模型是一种常见的并发编程模型，在Java中可以通过使用同步机制和wait/notify机制来实现。在本文中，我们将通过一个简单的示例代码介绍Java实现简易...
Java多线程 生产者消费者模型实例详解
08-25
Java多线程生产者消费者模型是指在多线程环境下，生产者线程生产任务，消费者线程消费任务，而缓冲区是生产者和消费者之间的媒介。生产者消费者模型的主要组成部分包括生产者、消费者和缓冲区三个部分。生产者负责...
理解生产者消费者模型及在Python编程中的运用实例
12-25
在生产者与消费者之间在加个缓冲区，我们形象的称之为仓库，生产者负责往仓库了进商 品，而消费者负责从仓库里拿商品，这就构成了生产者消费者模型。结构图如下： 生产者消费者模型的优点： 1、解耦 假设生产者和...
Java基于Lock的生产者消费者模型示例
08-27
Java基于Lock的生产者消费者模型示例 Java中的生产者消费者模型是指一个线程（生产者）生产数据，并将其存储在缓冲区中，而另一个线程（消费者）从缓冲区中取出数据并进行处理。Java中基于Lock的生产者消费者模型是...
JAVA仓库多线程存储,Java 多线程 生产者 消费者 仓库
weixin_29213655的博客
03-12 215
package thread.control;public class ConsumerThread extends Thread {private Warehouse warehouse;private int number;public ConsumerThread(Warehouse obj, int number) {warehouse = obj;this.number = number...
生产者消费者模型 线程池
weixin_30414635的博客
08-22 104
1.生产者消费者模型 　　主要是为解耦 　　借助队列来实现生产者消费这模型 　　栈:先进后出(First In Last Out 简称:FILO) 　　队列:先进先出(FIFO) import queue 　　from multiprocessing import Queue 借助Queue解决生产者消费这模型队列是安全的 　　q=Queue(m) 　　 q = Que...
生产者消费者模型、信号量、线程池以及单例模式的实现
liwenjie0的博客
07-23 310
生产者消费者模型！！---对典型的应用场景设计的解决方案 生产者与消费者模型应用场景：有线程不断的生产数据，有线程不断的处理数据。 数据的生产与数据的处理：放在同一个线程中完成，因为执行流只有一个，那么肯定是生产一个处理一个，处理一个后才能生产一个，这样的话依赖关系太强---如果处理比较慢，也会拖的生产速度慢下来。 因此将生产与处理放到不同的执行流中完成，中间增加一个数据缓冲区，作为中间的数据缓冲场所。 生产者与消费者解决的问题：1.解耦和 （将各个功能分离）2.支持忙闲不均/3.支持并发.
多线程与线程池技术详解
02-14
在当前的Java面试和后台开发中，多线程与线程池技术越来越重要。毫不夸张的说，如何你想进入任何一家好的网络公司并能够长足发展，多线程与线程池技术是必须要掌握的技能！
学习记录327@Java仓储模型
教练我想学编程
10-20 116
本质上仓储模型也是生产者消费者模型，只是多了一个仓库，仓库中添加和取出生产者和消费者共享的产品变量 //产品 package com.dream.test05; public class Cake { private String brand; private String date; public Cake() { super(); } public Cake(String brand, String date) { super(); this.brand = bran.
【Java并发编程】之十三：生产者—消费者模型（含代码）
技术崛起
03-28 501
生产者消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一存储空间，生产者向空间里生产数据，而消费者取走数据。     这里实现如下情况的生产--消费模型：     生产者不断交替地生产两组数据“姓名--1 --> 内容--1”，“姓名--2--> 内容--2”，消费者不断交替地取得这两组数据，这里的“姓名--1”和“姓名--2”模拟为数据的名称，“内容--1 ”
生产者消费者(c++、blockingqueue参考muduo库)
weixin_44403747的博客
01-05 523
本文基于c++面对对象模式设计一个blockingqueue类，该类隐藏锁的一些细节，只提供给用户一些简单的接口，不理解生产者消费者模式不影响阅读。 #include <pthread.h> #include <queue> template<typename T> class blockingqueue { blockingqueue(): deque_() { pthread_cond_init(&cond_,NULL); pthread_m
Java生产者消费者的五种实现方式
zgj12138的博客
06-30 4372
前言生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。 现在用四种方式来实现生产者消费者模型
java线程池实现生产者消费者模式
大造梦家的博客
01-08 3666
本人并发小白，如果有可以优化的地方欢迎评论交流～ 题目如下： ​  15个生产者生产1000条数据（从1开始，每生产一条加1），并向消息队列中存放字符串（“第m个生产者生产数据n”），同时3个消费者消费数据,并将数据n累加最后输出 代码如下： 生产者： package com.lcy.thread.parta; import java.util.concurrent.LinkedBlocking...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

雨霖先森

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值