生产消费多线程的模式代码

最新推荐文章于 2022-03-31 20:06:15 发布
最新推荐文章于 2022-03-31 20:06:15 发布
阅读量77 收藏
点赞数 1
分类专栏： Java基础 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49050026/article/details/119855602
版权

知识点：生产者消费者模型
注意：一个生产者一个消费者的情况
需求：生产一个消费一个
步骤：
1.让生产者线程和消费者线程 共同操作同一个电脑对象(资源)
2.让两个产品来回切换（目的是放大第一个步骤的问题）
加锁，防止脏数据的出现
3.生产一个消费一个

public class computer{
	//定义属性
	private String brand;
	private double price;
	private boolean isStore;//判断是否有库存

	public computer{}
	@Override
	public computer(String brand, double price){
		this.brand=brand;
		this.price=price;
	}

	public void getBrand(){return brand;}

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

	public void getPrice(){return price;}

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

	public void isStore(){return isStore;}

	public void setStore(Boolean store){isStore=store;}

}

public class Producer{
	private Computer computer;
	public Producer(Computer computer){this.computer=computer;}
	@Override
	public void run(){
		boolean flag=true;
		while(ture){
			synchronized(computer){
				try{
					computer.wait();
				}catch(InterruptedException e){
					e.printStackTrace();
				}
			}
			if(flag){
				computer.setBrand("华硕");
				computer.setPrice(6999);
			}else{
				computer.setBrand("联想");
				computer.setPrice(7999);
			}
			flag!=flag;//置反
			computer.setStore(true);//设置成有库存
			computer.notify();//唤醒
		}
	} 
}

public class Consumer{
	private Computer computer;
	public Consumer(Computer computer){
		this.computer=computer;
	}

	@Override
	public void run(){
		while(true){
			synchronized(computer){
				if(!computer.isStore){
					try{
						computer.wait();
					}catch(InterruptedException e){
						e.printStackTrace();
					}
				}
				System.out.println(computer.getBrand()+"----"+computer.getPrice());
				computer.setStore(false);
				computer.notify();
			}
		}
	}
}

public class Test{
	public static void main(String[] args){
        Computer computer=new Computer();
        Producer p=new Producer(computer);
        Consunmer c=new Consunmer(computer);
        p.start();
        c.start();
    }
}

	 * 知识点：生产者消费者模型
	 * 
	 * 注意：多个生产者多个消费者的情况
	 * 
	 * 需求：生产一个消费一个
	 * 
	 * 步骤：
	 * 		1.让生产者线程和消费者线程 共同操作同一个电脑对象(资源)
	 * 		2.让两个产品来回切换（目的是放大第一个步骤的问题）
	 * 			加锁，防止脏数据的出现
	 * 3.生产一个消费一个

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

public class Producer{
    private Computer computer;
    public Producer(Computer computer){this.computer=computer;}
    @Override
    public void run(){
		int flag=true;
        while(true){
            synchronized(computer){
                while(computer.isStore){
                	try{
                    	computer.wait();//等待
                	}catch(InterruptedException e){
                    	e.printStackTrace(); 
                	}
                }
                if(flag){
                    computer.getBrand("机械革命师");
                    computer.getPrice(6999);
                }else{
                    computer.getBrand("华硕");
                    computer.getPrice(9999);
                }
                flag!=flag;
                computer.setStore(true);
                computer.notifyAll();//唤醒
            }
        }
    }
}

public class Consunmer{
    private Computer computer;
    public Consunmer(Computer computer){
        this.computer=computer;
    }
    @Override
    public void run(){
        while(true){
            synchronized(computer){
                while(!computer.isStore){
                    try{
                        computer.wait();
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
                System.out.println(computer.getBrand()+"-------"+computer.getPrice());
                computer.setStore(false);
                computer.notifyAll();
            }
        }
    }
}

public class Test{
    public static void main(String[] args){
        Computer computer=new Computer();
        Consunmer c1=new Consunmer(computer);
        Producer  p1=new Producer(computer);
        Consumer  c2=new Consunmer(computer);
        Producer  p2=new Producer(computer);
        c1.start();
        c2.start();
        p1.start();
        p2.start();
    }
}

  • 知识点：仓储模型

  • 注意：一个生产者和一个消费者

public class Cake{
 private String brand;
 private String DataTime;

 public Cake(){}
 public Cake(String brand,String DataTime){
     this.brand=brand;
     this.DataTime=DataTime;
 }

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

 public void getDataTime(){ruturn DataTime;}
 public void setDataTime(String DataTime){this.DataTime=DataTime;}

}

public class Producer{
	private Store store;
 public Producer(Store store){
     this.store=store;
 }
 @Override
 public void run(){
     SimpleDateFromat sdf=new SimpleDateFromat("yyyy-MM-dd HH:mm:ss");
     while(true){
         Cake cake=new Cake("樱樱面包",sdf.format(new Date()));
         store.push(cake);
     }
 }

}

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

public class Store{
    private LinkedList<Cake> list=new LinkedList<>();
    private int maxCapacity=20;
    private int currentCapacity;
 
    public void push(Cake cake){
        synchronized(this){
            if(currentCapacity>=maxCapacity){
                try{
                    this.wait();
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
            list.add(cake);
            currentCacity++;
            System.out.println("入库，当前容量位："+currentCapacity);
            this.notify();//通过，对象监视器，唤醒，被等待的线程
        }
    }
    public void pop(){
        synchronized(this){
            if(currentCapacity<=0){
                try{
                    this.wait();
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
            Cake cake=list.removeFirst();
            currentCapacity--;
            System.out.println("出库，当前容量位："+currentCapacity);
            this.notify();
        }
    }
    
}

public class Test{
	/**
	 * 知识点：仓储模型
	 * 
	 * 注意：一个生产者一个消费者的情况
	 */
    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 String dataTime;
	
	public Cake() {
	}

	public Cake(String brand, String dataTime) {
		this.brand = brand;
		this.dataTime = dataTime;
	}

	public String getBrand() {
		return brand;
	}

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

	public String getDataTime() {
		return dataTime;
	}

	public void setDataTime(String dataTime) {
		this.dataTime = dataTime;
	}

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


public class Consumer extends Thread{
	
	private Store store;
	
	public Consumer(Store store) {
		this.store = store;
	}

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

public class Producer extends Thread{
	
	private Store store;
	
	public Producer(Store store) {
		this.store = store;
	}

	@Override
	public void run() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		while(true){
			Cake cake = new Cake("桃李面包", sdf.format(new Date()));
			store.push(cake);
		}
	}
}

public class Store {

	//蛋糕容器
	private LinkedList<Cake> list = new LinkedList<>();
	//最大容量
	private int maxCapacity = 20;
	//当前容量
	private int currentCapacity;
	
	
	//currentCapacity - 22
	
	//入库
	public void push(Cake cake){
		synchronized (this) {
			while(currentCapacity >= maxCapacity){
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			list.add(cake);
			currentCapacity++;
			System.out.println("入库，当前容量为：" + currentCapacity);
			this.notifyAll();
		}
	}
	
	//出库
	public void pop(){
		synchronized (this) {
			while(currentCapacity <= 0){
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			Cake cake = list.removeFirst();
			currentCapacity--;
			System.out.println("出库，当前容量为：" + currentCapacity + " -- " + cake);
		
			this.notifyAll();
		}
	}
}

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();
	}

}
榮十一
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
多生产与多消费：操作栈
weixin_34348111的博客
09-26 76
2019独角兽企业重金招聘Python工程师标准>>> ...
生产-消费者问题基本框架代码
I Hsien's BLOG
07-09 156
//基本变量 mutex=1;//临界区锁变量 empty=n;//空闲缓冲区数量，给producer校验 full=0;//有内容的缓冲区数量，给consumer校验，恒有full+empty=n //生产者 void producer() { p(empty);//校验是否有空缓冲区 p(mutex);//校验通过，锁闭临界区 save();//事务代码 v(full); v(mutex);//释放临界区 } //消费者 void consumer() { p(full); p(mutex
利用线程模拟一个简单的商品生产和消费
boy_chen93的博客
03-15 127
首先是商品类，里面有商品生产和扣库存的方法： package com.chen.test.demo3; /** * @Description: * @Author chenjianwen * @Date 2021/3/15 **/ public class Product { private static volatile int p = 1; //假设这里只有一个并保持一个有效商品 /** * 生产商品 * @throws InterruptedExc
多线程生产者消费者代码
luxin120的博客
11-21 187
public class Producers_Consumers { public static void main(String[] args) { //共同资源 Food food = new Food(); //多线程 Producers p = new Producers(food); Consumers c = new Consumers(food); ne...
解决线程问题-生产与消费
blblccc
12-12 298
package com.yby7; class Cleck{ private int productcount = 0; //生产产品 public synchronized void produceproduct(){ if (productcount < 20){ productcount ++; System.out.println(Thread.currentThread().getName()+"开始.
Java多线程生产者消费者模式实现过程解析
08-19
主要介绍了Java多线程生产者消费者模式实现过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
生产者和消费者模式多线程
07-26
使用多线程实现了生产者和消费者模式
Java多线程并发生产者消费者设计模式实例解析
08-19
主要介绍了Java多线程并发生产者消费者设计模式实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java 多线程 生产者消费者模式源码
08-21
java 多线程 生产者消费者模式，多个生产者对多个消费者，使用jdk 线程池及 BlockingQueue实现，解决了待生产的任务生产完成后，正常终止所有线程，避免线程(特别是消费者线程)因阻塞而无限等待的情况。源码中还简单...
C++ 多线程通信方式简介并结合生产者-消费者模式代码实现
10-15
C++ 多线程通信方式简介并结合生产者-消费者模式代码实现
JDBC学习笔记（动力节点+附代码分析）
Nohara Rin
03-15 2258
JDBC学习笔记 1.JDBC是什么？ Java DataBase Connectivity（Java语言连接数据库） 2.JDBC的本质是什么？ JDBC是SUN公司制定的一套接口(interface)。 接口都有调用者和实现者。 面向接口调用、面向接口写实现类，这都属于面向接口编程。 3.为什么要面向接口编程？ 解耦合：降低程序的耦合度，提高程序的扩展力。 多态机制就是非常典型的：面向抽象编程。（不要面向具体编程） [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OxfSi
栈的基本操作代码
qq_45728926的博客
04-06 1754
#include <stdio.h> #define M 1000 typedef struct { int elem[M]; int top; }stack;//stack是栈的意思 void init(stack &s)//构造空栈 { s.top = 0; } int getTop(stack s)//取栈顶元素 { return s.elem[s.top - 1...
Kafka消费者——消费者客户端多线程实现
6。
12-07 1189
目录 消费者客户端多线程实现 消费者客户端多线程实现 KafkaProducer 是线程安全的，然而 KafkaConsumer 却是非线程安全的。KafkaConsumer 中定义了一个 acquire() 方法，用来检测当前是否只有一个线程在操作，若有其他线程正在操作则会抛出 ConcurrentMo...
14 消费者多线程实现
，
01-09 660
消费者多线程实现 KafkaProducer 是线程安全的，而 KafkaConsumer 却是非线程安全的。KafkaConsumer中定义了一个 acquire() 方法用来检查当前是否只有一个线程在操作，如果有其他线程在操作那么就会抛出 ConcurrentModifcationException 异常。KafkaConsumer 所有公用方法在执行之前都会调用 acquire() 方法，只...
Java实现多线程中生产者、消费者问题，简单易懂
加贝要加倍努力的博客
02-01 5687
思想： 1、生产者在while循环里不停地生产“产品”，每生产一个，就交给店员，店员就得到一个产品 2、消费者在while循环里不停地消费产品，每消费一个，店员就移走一个产品 3、店员手里的产品少于20个，就从生产者那里拿走产品。等于20个，就停止从生产者那里拿走产品 4、店员手里的产品多于0个，就让消费者消费产品。等于0个，就停止让消费者消费产品 生产者： 生产者在while循环里不停地生产“产品”，每生产一个，就交给店员，店员就得到一个产品 //生产者 class Producte.
一看就会的kafka多线程顺序消费【内附Demo哦】
qq_32179907的博客
01-20 6081
Hello，这里是爱 Coding，爱 Hiphop，爱喝点小酒的 AKA 柏炎。 Kafka是一个分布式的，支持多分区、多副本，基于 Zookeeper 的分布式消息流平台，它同时也是一款开源的基于发布订阅模式的消息引擎系统。 kafka如何保证消息不丢失、顺序消费、重复消费？ 这三个问题熟不熟悉？是不是在面试的时候经常被问到，在日常工作中也经常碰到？ 保证消息不丢失与重复消费其实操作上还是比较简单的。是一些常规的八股文，本文不展开讨论，感兴趣的同学可以给我留言，我单独出一期讲解。 本文将着重与大家讨论K
生产者与消费者线程之间的通信
qq_56457318的博客
03-31 489
题目：生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处 取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图 生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通 知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如 果店中有产品了再通知消费者来取走产品。 首先考虑：是否是多线程问题？当然是，并且有哪些线程呢？生产者线程，消费者线程 （这里的线程不止一个）； 考虑是否存在有线程安全问题？线程安全首先考虑是否有共享数
（超详细笔记整理）动力节点_老杜 | JavaSE进阶 【P486之后】
热门推荐
小七自学博客
10-12 1万+
JavaSE进阶 文章目录JavaSE进阶final关键字1. final是Java语言中的关键字2. final表示最终的，不可变的3. final可以修饰变量以及方法还有类等4. final修饰的变量5. final修饰的局部变量无法重新赋值，final修饰的变量只能赋一次值6. final修饰的方法7. final修饰的类8. final修饰的引用9. final修饰的实例变量10. final和static联合修饰的变量-常量（每个单词都大写）总结抽象类和接口以及抽象类和接口的区别抽象类的理解1.
IDEA的小技巧：如何将自己写的类导出成JAR文件并使用
榮十一的博客
09-03 1911
首先先创建一个工具类，写入功能，再创建一个测试类进行调用工具类，从而使工具类在out/production文件夹下自动产生class文件，得到了写入的工具类的.class文件以后，再点击左上角file -> Project Structure -> Artifacts -> + -> JAR -> From modules with dependencies... ->Main Class: 中找到工具类.class的路径 -> OK -> Apply-&g.
observer多线程消费行情模式代码
最新发布
05-17
以下是一个简单的多线程消费行情模式的代码示例，使用了观察者模式： ```python from threading import Thread from time import sleep # 定义一个观察者类 class Observer: def __init__(self): self.observers = [] def register(self, observer): self.observers.append(observer) def notify(self, data): for observer in self.observers: observer.update(data) # 定义一个行情数据类，继承自观察者类 class MarketData(Observer): def __init__(self): super().__init__() self.data = None def update(self, data): self.data = data def start(self): # 模拟行情数据不停地更新 while True: data = get_market_data() self.notify(data) sleep(1) # 定义一个消费者类，继承自观察者类 class Consumer(Observer): def __init__(self, name): super().__init__() self.name = name def update(self, data): print(f"{self.name} received data: {data}") def start(self): # 模拟消费者不停地处理数据 while True: sleep(2) # 模拟获取行情数据的函数 def get_market_data(): return "market data" # 创建一个行情数据对象 market_data = MarketData() # 创建两个消费者对象 consumer1 = Consumer("Consumer1") consumer2 = Consumer("Consumer2") # 注册消费者对象到行情数据对象中 market_data.register(consumer1) market_data.register(consumer2) # 启动行情数据对象和消费者对象 Thread(target=market_data.start).start() Thread(target=consumer1.start).start() Thread(target=consumer2.start).start() ``` 在上面的代码中，行情数据对象（`MarketData`）继承自观察者类（`Observer`），用于不断地获取最新的行情数据，并将数据通知给所有注册的观察者对象。消费者对象（`Consumer`）同样继承自观察者类，用于接收行情数据，并进行消费处理。在主函数中，我们创建了一个行情数据对象和两个消费者对象，并将消费者对象注册到行情数据对象中。然后，我们启动了三个线程，分别用于启动行情数据对象和两个消费者对象的主要处理函数。这样，当行情数据对象获取到最新的行情数据后，就会通知所有注册的消费者对象，并让他们进行相应的处理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

榮十一

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

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

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

打赏作者

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

抵扣说明：

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

余额充值