Producter And Consumer

最新推荐文章于 2022-10-10 13:44:20 发布
最新推荐文章于 2022-10-10 13:44:20 发布
阅读量732 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014558484/article/details/52183896
版权 
package mypack;

import java.util.LinkedList;

public class Products<T> {
	private int MAX_SIZE=100;
	private LinkedList<T> products=new LinkedList<T>();
	public boolean isFull(){
		return products.size()==MAX_SIZE;
	}
	public boolean isEmpty(){
		return products.isEmpty();
	}
	public boolean addEnable(int num){
		return products.size()+num<MAX_SIZE?true:false;
	}
	public boolean getEnable(int num){
		return products.size()>num;
	}
    public T getProduct(){
    	return products.remove();
    }
    public void addProduct(T e){
    	products.add(e);
    }
}

用 wait() 和notify() notifyAll()实现

package mypack;

public class Producter implements Runnable {

	private Products<Integer> products;
	private int num;

	public Producter(Products<Integer> p) {
		products = p;
	}

	public void setNum(int n) {
		num = n;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			while (true) {
				synchronized (products) {
					while (!products.addEnable(num))
						products.wait();

					for (int i = 0; i < num; i++) {
						System.out.print(i + "  ");
						products.addProduct(i);
					}
					System.out.println("已生产品的个数为" + num);
					products.notifyAll();
				}
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("Producter interrupted");
		}
	}

}

package mypack;

public class Consumer implements Runnable {
	private int num;
	private Products<Integer> products;

	public Consumer(Products<Integer> p) {
		products = p;
	}

	public void setNum(int n) {
		num = n;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			while (true) {
				synchronized (products) {
					while (!products.getEnable(num)) 
						products.wait();
					
					for (int i = 0; i < num; i++)
						System.out.print(products.getProduct() + "  ");
					System.out.println("消费者消费产品的个数为" + num);
					products.notifyAll();
				}
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("Consumer interrupted");
		}
	}

}


package mypack;

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

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Products<Integer> products=new Products<>();
		ExecutorService exec = Executors.newCachedThreadPool();
		Producter p1 = new Producter(products);
		p1.setNum(15);
		Producter p2 = new Producter(products);
		p2.setNum(5);
		Producter p3 = new Producter(products);
		p3.setNum(10);
		
		Consumer c1 = new Consumer(products);
		c1.setNum(20);
		Consumer c2 = new Consumer(products);
		c2.setNum(5);
		exec.execute(p1);
		exec.execute(p2);
		exec.execute(p3);
		exec.execute(c1);
		exec.execute(c2);
		try {
			TimeUnit.MILLISECONDS.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		exec.shutdownNow();
	}

}

运用lock 和Condition  Test不变 

</pre><pre name="code" class="java">package mypack;

import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Products<T> {
	
	private ReentrantLock lock=new ReentrantLock();
	private  Condition full=lock.newCondition();
	private  Condition empty=lock.newCondition();
	private int MAX_SIZE=100;
	private LinkedList<T> products=new LinkedList<T>();
	public boolean isFull(){
		return products.size()==MAX_SIZE;
	}
	public boolean isEmpty(){
		return products.isEmpty();
	}
	public boolean addEnable(int num){
		return products.size()+num<MAX_SIZE?true:false;
	}
	public boolean getEnable(int num){
		return products.size()>num;
	}
    public T getProduct(){
    	return products.remove();
    }
    public void addProduct(T e){
    	products.add(e);
    }
    public void lockProducts(){
    	lock.lock();
    }
    public void unlockProducts(){
    	lock.unlock();
    }
    public void fullWait() throws InterruptedException{
    	full.await();
    }
    public void fullSingal(){
    	full.signalAll();
    }
    public void emptyWait() throws InterruptedException{
    	empty.await();
    }
    public void emptySinal(){
    	empty.signalAll();
    }
    
}


package mypack;

public class Producter implements Runnable {

	private Products<Integer> products;
	private int num;

	public Producter(Products<Integer> p) {
		products = p;
	}

	public void setNum(int n) {
		num = n;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			while (true) {
				try{
				products.lockProducts();
					while (!products.addEnable(num))
						products.fullWait();

					for (int i = 0; i < num; i++) {
						System.out.print(i + "  ");
						products.addProduct(i);
					}
					System.out.println("已生产品的个数为" + num);
					products.emptySinal();
				}finally{
					products.unlockProducts();
				}
			}
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("Producter interrupted");
		}
	}

}


package mypack;

public class Consumer implements Runnable {
	private int num;
	private Products<Integer> products;

	public Consumer(Products<Integer> p) {
		products = p;
	}

	public void setNum(int n) {
		num = n;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			while (true) {
				try{
					products.lockProducts();
					while (!products.getEnable(num)) 
						products.emptyWait();
					
					for (int i = 0; i < num; i++)
						System.out.print(products.getProduct() + "  ");
					System.out.println("消费者消费产品的个数为" + num);
					products.fullSingal();
				}
				finally{
					products.unlockProducts();
				}
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("Consumer interrupted");
		}
	}

}

用阻塞队列LinkedBlockingQueue 

package mypack;

import java.util.concurrent.LinkedBlockingQueue;

public class Products<T> {
	private int MAX_SIZE=100;
	private LinkedBlockingQueue<T> products=new LinkedBlockingQueue<>(MAX_SIZE);
	public boolean isFull(){
		return products.size()==MAX_SIZE;
	}
	public boolean isEmpty(){
		return products.isEmpty();
	}
	public boolean addEnable(int num){
		return products.size()+num<MAX_SIZE?true:false;
	}
	public boolean getEnable(int num){
		return products.size()>num;
	}
    public T getProduct() throws InterruptedException{
    	return products.take();
    }
    public void addProduct(T e) throws InterruptedException{
    	products.put(e);
    }
}

package mypack;

public class Producter implements Runnable {

	private Products<Integer> products;
	private int num;

	public Producter(Products<Integer> p) {
		products = p;
	}

	public void setNum(int n) {
		num = n;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			while (true) {
				
					for (int i = 0; i < num; i++) {
						System.out.print(i + "  ");
						products.addProduct(i);
					}
					System.out.println("已生产品的个数为" + num);
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("Producter interrupted");
		}
	}

}


package mypack;

public class Consumer implements Runnable {
	private int num;
	private Products<Integer> products;

	public Consumer(Products<Integer> p) {
		products = p;
	}

	public void setNum(int n) {
		num = n;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			while (true) {
					for (int i = 0; i < num; i++)
						System.out.print(products.getProduct() + "  ");
					System.out.println("消费者消费产品的个数为" + num);
				}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			System.out.println("Consumer interrupted");
		}
	}
}





踏雪留印
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Producter：让产品从0到1
GitChat
04-12 4789
内容简介 这是一本以实际的成功 App 为例阐述如何完成一款 App 产品的设计、开发和营销的书。本书从产品的设计、产品的实现、产品的迭代、产品的营销、产品的进阶等几个角度，全面讲解了产品设计的基本原则、设计的重要性、设计的感觉、实用的设计工具、简单的 iOS 开发、产品营销理念和文案基础、动画效果的实现等内容。此外，本书以《小记》这款有代表性的 App 产品为例，完整还原了一款产品从想法到设计，...
producter_1.2.5.pdf
03-12
这本书主要涵盖了，设计原理，原型，动效，交互设计，iOS开发，营销等
producter 产品从0到1
11-20
周楷雯写的关于产品设计的一本书，包括排版、美学、这些
producter
xiexuzhao的专栏
06-04 932
producter customer eureka get resources https://blog.didispace.com/spring-cloud-learning/ https://www.cnblogs.com/typ1805/p/9708486.html https://www.cnblogs.com/zddsl/p/12798143.html https://www.cnblogs.com/F017/p/12065766.html 网关 https://www.cnblogs.com/
product-consumer
weixin_30367873的博客
07-24 76
1参考多线程读写文件2以下转贴3usingSystem;4usingSystem.Threading;5usingSystem.IO;67namespaceCopyTest8{910//FileBuffer用来存放和取出缓冲区变量11...
ProducerAndConsumer:生产者和消费者模型java实现
05-17
Thread consumerThread = new Thread(new Consumer(queue)); producerThread.start(); consumerThread.start(); } ``` 在这个实现中，生产者和消费者之间的通信是通过`BlockingQueue`完成的，无需手动加锁或...
Producer-and-consumer-C.zip_操作系统开发_C/C++_
08-11
标题中的"Producer-and-consumer-C.zip"提示我们这是一个关于生产者-消费者问题的C语言实现。生产者-消费者问题是多线程同步的经典案例，常见于操作系统设计和并发编程中。在这一问题中，"生产者"负责生成数据，而...
Python-kafka集群搭建PythonAPI调用Producer和Consumer
08-12
在本教程中，我们将探讨如何搭建一个支持SASL（Simple Authentication and Security Layer）认证的Kafka集群，并使用Python API来创建Producer和Consumer。 ### 1. 安装Kafka 首先，我们需要在服务器上安装...
SALSA - Scalable and Low Synchronization NUMA-aware Algorithm for Producer-Consumer Pools (spaa049-gidron)-计算机科学
04-22
Algorithm for Producer-Consumer PoolsElad Gidron CS DepartmentTechnion, Haifa, Israel eladgi@cs.technion.ac.ilIdit Keidar EE DepartmentTechnion, Haifa, Israel idish@ee.technion.ac.ilDmitri Perelman ∗...
Producer-Consumer-System:实施多种生产者－消费者系统，其中生产者创造优先工作
04-16
// Producer process_id int producer_no; // Producer Number int priority; // Priority between 1 and 10 int compute_time; // Compute Time between 1 and 4 int job_id; // Job ID betwee
Producter | 让产品从0到1
03-15
这是一本以App Store首页推荐的成功App为例阐述如何完成一款App产品的设计、开发和营销的书。在这本书之后，作者的《一炷香》和《字里行间》两款产品也接连被App Store首页推荐。 《Producter 让产品从0到1》从产品的设计、产品的实现、产品的迭代、产品的营销、产品的进阶等几个角度，全面讲解了产品设计的基本原则、设计的重要性、设计的感觉、实用的设计工具、简单的iOS开发、产品营销理念和文案基础、动画效果的实现等内容。 此外，《Producter 让产品从0到1》以《小记》这款有代表性的App产品为例，完整还原了一款产品从想法到设计，到编码实现，到上架发布，再到营销的全过程。
ProductConsumeProblem
08-27
博客专栏——java多线程（九）阻塞队列，生产者消费者问题源码，详情见相应的博客
在Kafka中使用Avro编码消息：Producter篇
weixin_30739595的博客
05-09 164
本文将介绍如何在Kafka中使用 Avro 来序列化消息，并提供完整的 Producter 代码共大家使用。 Avro Avro 是一个数据序列化的系统，它可以将数据结构或对象转化成便于存储或传输的格式。Avro设计之初就用来支持数据密集型应用，适合于远程或本地大规模数据的存储和交换。因为本文并不是专门介绍 Avro 的文章，如需要更加详细地了解，请参见《Apache Avro使用入门指南...
RabbitMQ中的生产者Producer，消费者Consumer，服务节点Broker，队列Queue和Exchange交换机
m0_58524181的博客
10-10 2139
RabbitMQ中的生产者Producer，消费者Consumer，服务节点Broker，队列Queue和Exchange交换机
生产者与消费者（C#）
guhongyi的专栏
03-22 2291
using System;using System.Threading;//我们定义一个被操作的对象的类Cell，在这个类里，有两个方法：ReadFromCell()和WriteToCell。//消费者线程将调用ReadFromCell()读取cellContents的内容并且显示出来，生产者进程将调用WriteToCell()方法向cellContents写入数据。public class Ce
Kakfa-Server配置文件
weixin_34101784的博客
11-21 206
------------------------------------------- 系统 相关 ------------------------------------------- 每一个broker在集群中的唯一标示，要求是正数。在改变IP地址，不改变broker.id的话不会影响consumers broker.id =1listeners=P...
Java:多线程Producer-Consumer的多种实现
Al_assad的博客
11-01 1604
多线程Producer-Consumer的多种实现 更多类型Product-Consumer的实现：https://github.com/Al-assad/Produer-Consumer 1、使用老式synchronized互斥锁实现： /** * @see * @author Al_assad yulinying_1994@outlook.com * @date 2016年1
类部分的笔记
weixin_65734716的博客
04-17 93
public class Test { public static void main(String[] args) { int num;//定义了一个int类型的变量num num=123; //new用来创建对象——给对象开辟储存空间 Product p1=new Product();//定义了一个Product类型的变量p1 Shop shop1=new Shop(); User user1=new User(); p1.productId=1; ...
Python中的生产者消费者问题
wakeUpJava
12-05 1347
我们将使用Python线程来解决Python中的生产者—消费者问题。这个问题完全不像他们在学校中说的那么难。 如果你对生产者—消费者问题有了解，看这篇博客会更有意义。 为什么要关心生产者—消费者问题： 可以帮你更好地理解并发和不同概念的并发。信息队列中的实现中，一定程度上使用了生产者—消费者问题的概念，而你某些时候必然会用到消息队列。 当我们在使用线程时，你可以学习以下的线
producer and consumer problem with semaphore and lock
最新发布
05-11
The problem arises when the buffer is full, and the producer needs to wait until the consumer has consumed some items before it can add more, and when the buffer is empty, and the consumer needs to ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值