Java:多线程Producer-Consumer的多种实现

最新推荐文章于 2023-07-30 21:33:53 发布
最新推荐文章于 2023-07-30 21:33:53 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： Java 文章标签： java 多线程 并发 Producer-Consumer 生产者消费者
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/al_assad/article/details/52992734
版权

多线程Producer-Consumer的多种实现


更多类型Product-Consumer的实现：https://github.com/Al-assad/Produer-Consumer

1、使用老式synchronized互斥锁实现：

/**
* @see
* @author Al_assad yulinying_1994@outlook.com
* @date 2016年10月28日 上午1:15:49
* @version V1.0  
* Description: Product-Consumer模型使用的Product类
*/

public class Product {
	private int typeId;  //产品种类编号 
	public Product(int typeId){
		this.typeId = typeId;
	}
	public int getType(){
		return this.typeId;
	}
	public String toString(){
		return "Product"+this.typeId; 
	}
}

/**
* @see Product
* @author Al_assad yulinying_1994@outlook.com
* @date 2016年10月28日 下午4:57:04
* @version V1.0  
* Description: product仓库类，负责维护products列表的同步更新；
*/

import java.util.*;

public class ProductRepository {
	
	private Queue<Product> products = new LinkedList<Product>();  //产品列表
	private final int limit;   //仓库中的产品最大存放量
	public ProductRepository(int limit){
		this.limit = limit;
	}
	//任务线程发送product对象到本products
	public synchronized void send(Product product) throws InterruptedException{
		while(products.size() >= limit)
			wait();
		products.offer(product);
//		System.out.println(products.size());  //打印仓库product数量
		notifyAll();
	}
	//任务线程从本products获取一个product对象
	public synchronized Product get() throws InterruptedException{
		while(products.size() == 0)
			wait();
		Product product = null;
		product = products.poll();
//		System.out.println(products.size());  //打印仓库product数量
		notifyAll();
		return product;
	}
	
	public synchronized Queue<Product> getProducts(){
		return products;
	}
	public int getLimit(){
		return limit;
	}


}

 @see Product.java ProductRepository.java
* @author Al_assad yulinying_1994@outlook.com
* @date 2016年10月28日 上午1:19:31
* @version V1.0  
* Description: Product-Consumer模型使用的Consumer类；
* 			   
*/
import java.util.concurrent.*;
import java.util.*;
public class Consumer implements Runnable{
	private ProductRepository repository;

	private static volatile int count = 0;  //记录累计Consumer的创建数量
	private int id = 0;    //记录Consumer的id
	
	public Consumer(ProductRepository repository){

		this.repository = repository;
		id = count;
		count++;
	}
	public String toString(){ 
		return "Producer"+id;
	}
	public void run(){
		try{
			while(!Thread.interrupted()){
				Product product = repository.get();  //在这里可以通过product.getType()获取product种类，采取不同的处理操作
				System.out.println(this+" got "+product);
				TimeUnit.MILLISECONDS.sleep(new Random().nextInt(500));  //模拟消费时间
			}
		}catch(InterruptedException ex){
			System.out.println(this+" intrrupted!");
		}
		
	}
	
}

/**
* @see  Product.java ProductRepository.java
* @author Al_assad yulinying_1994@outlook.com
* @date 2016年10月28日 上午1:19:05
* @version V1.0  
* Description: Product-Consumer模型使用的Producer类
*/
import java.util.concurrent.*;
import java.util.*;
public class Producer implements Runnable{
    private ProductRepository repository;
    private int typeId;  //记录生产product的种类id
    private static volatile int count = 0;  //记录累计Producer的创建数量
    private int id = 0;    //记录Producer的id
    public Producer(ProductRepository repository,int typeId){
        this.typeId = typeId;
        this.repository = repository;
        id = count;
        count++;
    }
    public String toString(){
        return "Producer"+id;
    }
    public void run(){
        try{
            while(!Thread.interrupted()){
                Product product = new Product(typeId);  //生产工作分配到各线程，减少高创建成本对象的创建时间；
                TimeUnit.MILLISECONDS.sleep(new Random().nextInt(500));  //模拟生产时间
                System.out.println(this+" sent "+product);
                repository.send(product);
    
            }
        }catch(InterruptedException ex){
            System.out.println(this+" intrrupted!");
        }
        
    }
}

/**
* @see  Product.java ProductRepository.java Consumer.java Producer.java
* @author Al_assad yulinying_1994@outlook.com
* @date 2016年10月28日 上午1:25:00
* @version V1.0  
* Description: 单一种类product测试类；
*                每一个Driver实例只能实现一种类型的Product的交易;
*/
import java.util.concurrent.*;

public class Driver {
    private ProductRepository repository;
    private int typeId;     //指定该driver交易使用的product种类；
    public Driver(int typeId,int limit,int producerSize,int consumerSize,int runSec) throws InterruptedException{
        this.typeId = typeId;
        repository = new ProductRepository(limit);
        ExecutorService exec = Executors.newCachedThreadPool();
        for(int i=0;i<producerSize;i++)
            exec.execute(new Producer(repository,typeId));
        for(int i=0;i<consumerSize;i++)
            exec.execute(new Consumer(repository));
        TimeUnit.SECONDS.sleep(runSec);
        exec.shutdownNow();
    }
    public int getTypeId(){
        return this.typeId;
    }
/*    //Test
    public static void main(String[] args) throws InterruptedException{
        new Driver(0,10,20,25,10);
//        new Driver(1,8,10,10,10);
//        new Driver(2,15,12,5,10);
    }*/
    
    

}


2、使用BlockingQueue实现；

/**
* @see  Product.java 
* @author Al_assad yulinying_1994@outlook.com
* @date 2016年10月28日 上午1:19:05
* @version V1.0  
* Description: Product-Consumer模型使用的Producer类
*/
import java.util.concurrent.*;
import java.util.*;
public class Producer implements Runnable{
	private BlockingQueue<Product> products;
	private int typeId;  //记录生产product的种类id
	private static volatile int count = 0;  //记录累计Producer的创建数量
	private int id = 0;    //记录Producer的id
	public Producer(BlockingQueue<Product> products,int typeId){
		this.typeId = typeId;
		this.products = products;
		id = count;
		count++;
	}
	public String toString(){
		return "Producer"+id;
	}
	public void run(){
		try{
			while(!Thread.interrupted()){
				Product product = new Product(typeId);  //生产工作分配到各线程，减少高创建成本对象的创建时间；
				TimeUnit.MILLISECONDS.sleep(new Random().nextInt(500));  //模拟生产时间
				products.put(product);
				System.out.println(this+" sent "+product);
			}
		}catch(InterruptedException ex){
			System.out.println(this+" intrrupted!");
		}
		
	}
}
/**
* @see Product.java 
* @author Al_assad yulinying_1994@outlook.com
* @date 2016年10月28日 上午1:19:31
* @version V1.0  
* Description: Product-Consumer模型使用的Consumer类；
*                
*/
import java.util.concurrent.*;
import java.util.*;
public class Consumer implements Runnable{
    private BlockingQueue<Product> products;
    private static volatile int count = 0;  //记录累计Consumer的创建数量
    private int id = 0;    //记录Consumer的id
    
    public Consumer(BlockingQueue<Product> products){
        this.products = products;
        id = count;
        count++;
    }
    public String toString(){ 
        return "Producer"+id;
    }
    public void run(){
        try{
            while(!Thread.interrupted()){
                Product product = products.take();  //在这里可以通过product.getType()获取product种类，采取不同的处理操作
                System.out.println(this+" got "+product);
                TimeUnit.MILLISECONDS.sleep(new Random().nextInt(500));  //模拟消费时间
            }
        }catch(InterruptedException ex){
            System.out.println(this+" intrrupted!");
        }
        
    }
    
}

/**
* @see
* @author Al_assad yulinying_1994@outlook.com
* @date 2016年10月28日 上午1:15:49
* @version V1.0  
* Description: Product-Consumer模型使用的Product类
*/

public class Product {
    private int typeId;  //产品种类编号 
    public Product(int typeId){
        this.typeId = typeId;
    }
    public int getType(){
        return this.typeId;
    }
    public String toString(){
        return "Product"+this.typeId; 
    }
}

/**
* @see  Product.java Consumer.java Producer.java
* @author Al_assad yulinying_1994@outlook.com
* @date 2016年10月28日 上午1:25:00
* @version V1.0  
* Description: 单一种类product测试类；
*                每一个Driver实例只能实现一种类型的Product的交易;
*/
import java.util.concurrent.*;

public class Driver {
    private BlockingQueue<Product> products;
    private int typeId;     //指定该driver交易使用的product种类；
    public Driver(int typeId,int limit,int producerSize,int consumerSize,int runSec) throws InterruptedException{
        this.typeId = typeId;
        products = new ArrayBlockingQueue<Product>(limit);
        ExecutorService exec = Executors.newCachedThreadPool();
        for(int i=0;i<producerSize;i++)
            exec.execute(new Producer(products,typeId));
        for(int i=0;i<consumerSize;i++)
            exec.execute(new Consumer(products));
        TimeUnit.SECONDS.sleep(runSec);
        exec.shutdownNow();
    }
    public int getTypeId(){
        return this.typeId;
    }
    //Test
    public static void main(String[] args) throws InterruptedException{
        new Driver(0,10,20,25,10);
//        new Driver(1,8,10,10,10);
//        new Driver(2,15,12,5,10);
    }
    
    

}





Al_assad
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单独KafkaConsumer实例and多worker线程。
HiterCoder
06-02 492
单独KafkaConsumer实例and多worker线程。 1、单独KafkaConsumer实例and多worker线程。将获取的消息和消息的处理解耦，将消息的处理放入单独的工作者线程中，即工作线程中，同时维护一个或者若各干consumer实例执行消息获取任务。本例使用全局的KafkaConsumer实例执行消息获取，然后把获取到的消息集合交给...
KafkaConsumer多线程优化
咖啡的博客
12-10 2131
优化目的: KafkaConsumer是以单线程模式运行，为了提升consumer的消费能力，多线程是一个很好的选择。KafkaConsumer和KafkaProducer不同，后者是线程安全的，因此我们鼓励用户在多个线程中共享一个KafkaProducer实例，这样通常都要比每个线程维护一个KafkaProducer实例效率要高。但对于KafkaConsumer而言，它不是线程安全的，所以实现多...
kafka消费者（Consumer）端多线程消费的实现方案
wangdawei_的博客
04-23 9150
kafka消费者（Consumer）端多线程消费的实现方案kafka Java consumer设计原理设计原理为什么用单线程设计多线程方案：方案一：方案二：两个方案的优缺点： kafka Java consumer设计原理 设计原理   首先，kafka Java consumer是单线程的设计。准确来说是双线程，从kafka 0.10.1.0版本开始kafkaConsumer变成了用户主线程和心跳线程的双线程设计。   所谓用户主线程，就是你启动Consumer应用程序的main方法的那个线程。而心跳线
【转载】Kafka Consumer多线程消费
sinat_36005594的博客
05-08 449
尊重原创！ 原文地址：https://www.cnblogs.com/huxi2b/p/13668061.html 阅读目录 概述 OrdinaryConsumer类 ConsumerWorker.java MultiThreadedConsumer.java MultiThreadedRebalanceListener.java Test.java 上一篇《Kafka Consumer多线程实例续篇》修正了多线程提交位移的问题，但依然可能出现数据丢失的情况，原因在于多个线程可能拿到..
Apache Kafka系列(四) 多线程Consumer方案
weixin_30687051的博客
08-20 157
Apache Kafka系列(一) 起步 Apache Kafka系列(二) 命令行工具（CLI） Apache Kafka系列(三) Java API使用 Apache Kafka系列(四) 多线程Consumer方案 Apache Kafka系列(五) Kafka Connect及FileConnector示例 本文的图片是通过PPT截图出的，读者如果修改意见请联系我 一、...
4.5 Kafka Consumer API之多线程并发处理
Steven的博客
08-07 365
1.consumer一对一消费partition (1).简介 这种类型是经典模式，每一个线程单独创建一个KafkaConsumer消费一个partition，用于保证线程安全。 (2).代码示例 public class KafkaConsumerRunner implements Runnable { private static final String topicName = "steven"; //状态开关，如果值为false则进行线程任务处理 private final
ProducerConsumerProblem:CSE310理论作业-线程
05-26
解决方案是使生产者进入睡眠状态，当消费者移除一件或多件物品时将其唤醒。 类似地，当消费者想要从缓冲区中删除一个项目并看到缓冲区为空时，它将进入睡眠状态，直到生产者将某些东西放入缓冲区中并唤醒消费者为止...
Producer/Consumer 多线程处理文件
03-21
非常好的程序资源，一秒钟一千多条！
producer_consumer_using_multithreading_in_java:用Java实现的经典生产者消费者问题的多线程解决方案
04-28
producer_consumer_using_multithreading_in_java 用Java实现的经典生产者消费者问题的多线程解决方案
Producer产生一个数字而Consumer消费这个数字.rar_java 多线程_producer.java_生产者消费者_
09-22
java的多线程示例（生产者消费者问题）
JAVA多线程实现2个producer和一个Consumer把整数放入到一个环形缓冲Circle Buffer中
06-28
采用同步机制synchronized/wait(notify)或者lock(unlock)/condition variable实现两个producer和一个consumer之间协调运行。运行结果输出格式为：Put(or Get) number {[content] length start_index end_index} 包含...
kafka Consumer 消费者使用多线程并发执行，并保证顺序消费， 第一种使用纯线程方式、第二种使用Executors线程池
AutoEE-自动智能开发平台
08-25 3790
kafka Consumer 消费者 多线程 顺序消费 Executors 线程池
Java中的生产者/消费者模型
最新发布
u010257931的博客
07-30 3483
生产者-消费者模型（Producer-Consumer problem）是一个非常经典的多线程并发协作的模型。比如某个模块负责生产数据，而另一个模块负责处理数据。产生数据的模块就形象地被称为生产者；而处理数据的模块，则被称为消费者。生产者和消费者在同一段时间内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。
Java实现生产者消费者问题
王梦杰_MengJie
04-26 4129
生产者-消费者问题是计算机科学中经典的同步问题之一，它描述了多个线程在共享数据的情况下如何协同工作。该问题通常涉及到一个共享缓冲区，其中生产者线程生成数据并将其放入缓冲区，而消费者线程从缓冲区中取出数据并对其进行处理。生产者和消费者线程必须协同工作，以避免竞态条件和死锁等问题。以上为通过Java代码实现解决生产消费者问题的实例，通过本实例希望大家能学会如果解决此问题，学会如何数据共享时，各个线程协同工作。
Java producer-consumer(生产者/消费者模式)
followwwind的博客
10-19 2305
生产者消费者模式并不是GOF提出的23种设计模式之一，23种设计模式都是建立在面向对象的基础之上的，但其实面向过程的编程中也有很多高效的编程模式，生产者消费者模式便是其中之一，它是我们编程过程中最常用的一种设计模式。      在java应用中，生产者/消费者模式的实现有以下五种:      1:wait() / nofity()方法是基类Object的两个方法，也就意味着所有Java类都会拥
架构设计：生产者/消费者模式
12-08 1199
[0]：概述今天打算来介绍一下“生产者／消费者模式”，这玩意儿在很多开发领域都能派上用场。由于该模式很重要，打算分几个帖子来介绍。今天这个帖子先来扫盲一把。如果你对这个模式已经比较了解，请跳过本扫盲帖，直接看下一个帖子（关于该模式的具体应用）。看到这里，可能有同学心中犯嘀咕了：在四人帮（GOF）的23种模式里面似乎没听说过这种嘛！其实GOF那经典的23种模式主要是基于OO的（从书名《Des
Java多线程：Producer-Consumer不同的几种实现方式
langjian2012的专栏
03-22 2728
生产者消费者问题是一个典型的线程同步问题。 主要有如下实现方式： wait() notifyAll() class Queue { //共享队列的目的用于保存生产者生产和消费者消费的共享数据 int value = 0; boolean isEmpty = true; public synchronized void put(
java版的producer开发流程
鸭鸭的博客
01-21 2707
java版的producer开发流程 文章目录java版的producer开发流程1、构造 Properties 对象2、构造 Kafka Producer 对象3、 构造 ProducerRecord 对象4、发送消息4.1、异步发送4.2、同步发送4.3、异常信息5、关闭producer Java 版本 producer 工作流程如图： Java 版本 producer 工作流程 import java.util.Properties; import org.apache.kafka.clients
Kafka学习笔记(三):使用Java进行Producer 开发
BlueLotuss的博客
10-16 1244
上一篇文章中，我们了解到了Kafka中的特有术语以及topic的相关概念，详细内容可以参考 kafka学习笔记(二):理解Kafka集群与Topic。接下来我们将使用 Java 语言调用 Kafka的相关 API，今天首先了解一下对于Producer的相关操作。 添加依赖 首先我们添加maven依赖，包括下面两个依赖 <dependency> <groupId>org.apache.kafka</groupId>
用java实现多线程消费者和生产者模型
02-26
好的，以下是一个使用Java语言实现的生产者和消费者模型的示例： ``` import java.util.LinkedList; public class ProducerConsumerExample { public static void main(String[] args) { LinkedList<Integer> queue = new LinkedList<>(); int maxSize = 5; Producer producer = new Producer(queue, maxSize); Consumer consumer = new Consumer(queue); Thread producerThread = new Thread(producer, "Producer"); Thread consumerThread = new Thread(consumer, "Consumer"); producerThread.start(); consumerThread.start(); } } class Producer implements Runnable { private LinkedList<Integer> queue; private int maxSize; public Producer(LinkedList<Integer> queue, int maxSize) { this.queue = queue; this.maxSize = maxSize; } @Override public void run() { while (true) { synchronized (queue) { while (queue.size() == maxSize) { try { System.out.println("队列已满，生产者等待消费..."); queue.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } int number = (int) (Math.random() * 100); queue.add(number); System.out.println("生产者生产: " + number); queue.notifyAll(); } } } } class Consumer implements Runnable { private LinkedList<Integer> queue; public Consumer(LinkedList<Integer> queue) { this.queue = queue; } @Override public void run() { while (true) { synchronized (queue) { while (queue.isEmpty()) { try { System.out.println("队列为空，消费者等待生产..."); queue.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } int number = queue.removeFirst(); System.out.println("消费者消费: " + number); queue.notifyAll(); } } } } ``` 上述代码实现了一个简单的生产者和消费者模型，其中使用了一个线程安全的`LinkedList`队列作为生产者和消费者之间的缓冲区。在`Producer`和`Consumer`类中，`run()`方法被覆盖并实现了生产和消费的逻辑。 在生产者线程中，如果队列已满，则生产者线程将进入等待状态。当队列不满时，生产者线程将生成随机数并将其添加到队列中，并通过调用`notifyAll()`方法通知消费者线程可以消费了。在消费者线程中，如果队列为空，则消费者线程将进入等待状态。当队列不为空时，消费者线程将从队列中删除第一个元素，并通过调用`notifyAll()`方法通知生产者线程可以继续生产。 这种实现方式使用`synchronized`关键字确保在对队列进行修改时线程安全。此外，生产者和消费者线程之间的通信使用了`wait()`和`notifyAll()`方法，以确保生产者和消费者之间的协调。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值