生产者消费者模式

最新推荐文章于 2021-03-29 17:17:02 发布
最新推荐文章于 2021-03-29 17:17:02 发布
阅读量266 收藏
点赞数 1
分类专栏： 多线程编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjl1991309/article/details/81370114
版权

目录

 

适用情景

概念和原理

设计要点

阻塞队列方式实现

notify()和wait()实现

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

注：本文参考生产者消费者模式

适用情景

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这种生产消费能力不均衡的问题，所以便有了生产者和消费者模式。

概念和原理

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

这个阻塞队列就是用来给生产者和消费者解耦的。纵观大多数设计模式，都会找一个第三者出来进行解耦，如工厂模式的第三者是工厂类，模板模式的第三者是模板类。在学习一些设计模式的过程中，如果先找到这个模式的第三者，能帮助我们快速熟悉一个设计模式。

设计要点

  • 生产者只在仓库未满时进行i生产，仓库满时生产者线程被阻塞
  • 消费者只在仓库非空时进行消费，仓库为空时消费者线程被阻塞
  • 当消费者发现仓库为空时会通知生产者生产
  • 当生产者发现仓库满时会通知消费者消费

阻塞队列方式实现

  • 实体类（生产和消费的产品）

package com.zjl.thread;

public class Data {

	private final int intData;

	public Data(int intData) {
		this.intData = intData;
	}

	public Data(String str) {
		this.intData = Integer.parseInt(str);
	}

	public int getIntData() {
		return intData;
	}

	@Override
	public String toString() {
		return "Data [intData=" + intData + "]";
	}

}
  • 生产者
package com.zjl.thread;

import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class Producer implements Runnable{

	private volatile boolean isRunning = true;
	private BlockingQueue<Data> queue;
	private static AtomicInteger count = new AtomicInteger();
	private static final int SLEEPTIME = 1000;
	
	public Producer(BlockingQueue<Data> queue) {
		this.queue = queue;
	}
	
	@Override
	public void run() {
		Data data = null;
		Random random = new Random();
		System.out.println("start producting id:" + Thread.currentThread().getId());
			try {
				while (isRunning) {
					Thread.sleep(random.nextInt(SLEEPTIME));
					data = new Data(count.incrementAndGet());
					System.out.println(data + "加入队列。");
					if (!queue.offer(data, 2, TimeUnit.SECONDS)) {
						System.out.println("加入队列失败！");
					}
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
				Thread.currentThread().interrupt();
			}
	}
	
	public void stop() {
		isRunning = false;
	}

}
  • 消费者
package com.zjl.thread;

import java.text.MessageFormat;
import java.util.Random;
import java.util.concurrent.BlockingQueue;

public class Consumer implements Runnable {

	private BlockingQueue<Data> queue;
	private static final int SLEEPTIME = 1000;

	public Consumer(BlockingQueue<Data> queue) {
		this.queue = queue;
	}

	@Override
	public void run() {
		System.out.println("start consumer id:" + Thread.currentThread().getId());
		Random random = new Random();
		try {
			while (true) {
				Data data = queue.take();
				if (data != null) {
					int re = data.getIntData() * data.getIntData();
					System.out.println(MessageFormat.format("{0}*{1}={2}", data.getIntData(), data.getIntData(), re));
					Thread.sleep(random.nextInt(SLEEPTIME));
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
			Thread.currentThread().interrupt();
		}
	}

}
  • 测试类
package com.zjl.thread;

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

public class QueueTest {

	public static void main(String[] args) throws InterruptedException {
		BlockingQueue<Data> queue = new LinkedBlockingDeque<>(10);
		Producer p1 = new Producer(queue);
		Producer p2 = new Producer(queue);
		Producer p3 = new Producer(queue);
		Consumer c1 = new Consumer(queue);
		Consumer c2 = new Consumer(queue);
		Consumer c3 = new Consumer(queue);
		ExecutorService service = Executors.newCachedThreadPool();
		service.execute(p1);
		service.execute(p2);
		service.execute(p3);
		service.execute(c1);
		service.execute(c2);
		service.execute(c3);
		Thread.sleep(10 * 1000);
		p1.stop();
		p2.stop();
		p3.stop();
		Thread.sleep(3000);
		service.shutdown();
	}
}
  • 执行效果如下
start producting id:11
start producting id:12
start producting id:10
start consumer id:15
start consumer id:14
start consumer id:13
Data [intData=1]加入队列。
1*1=1
Data [intData=2]加入队列。
2*2=4
Data [intData=3]加入队列。
3*3=9
Data [intData=4]加入队列。
4*4=16
Data [intData=5]加入队列。
5*5=25
Data [intData=6]加入队列。
6*6=36
Data [intData=7]加入队列。
7*7=49
Data [intData=8]加入队列。
8*8=64
Data [intData=9]加入队列。
9*9=81
Data [intData=10]加入队列。
10*10=100
Data [intData=11]加入队列。
11*11=121
Data [intData=12]加入队列。
12*12=144
Data [intData=13]加入队列。
13*13=169
Data [intData=14]加入队列。
14*14=196
Data [intData=15]加入队列。
15*15=225

总结：

因为 BlockingQueue 是阻塞队列，特点如下：

它的存取可以保证只有一个线程在进行操作

生产者在队列满时会阻塞，并唤醒消费者线程

消费者在队列为空时会阻塞，并唤醒生产者线程

notify()和wait()实现

  • 产品类
package com.zjl.concurrent;

public class Data {
	private long value;

	public Data() {
		super();
	}

	public Data(long value) {
		super();
		this.value = value;
	}

	public long getValue() {
		return value;
	}

	public void setValue(long value) {
		this.value = value;
	}

	@Override
	public String toString() {
		return "Data [value=" + value + "]";
	}

}
  • 生产者
package com.zjl.concurrent;

import java.util.List;
import java.util.Random;

public class Producer implements Runnable{

	private List<Data> queue;
	private int size;
	private static final int SLEEPTIME = 1000;
	
	public Producer(List<Data> queue, int size) {
		this.queue = queue;
		this.size = size;
	}
	
	@Override
	public void run() {
			try {
				Random random = new Random();
				while (true) {
					if (Thread.currentThread().isInterrupted()) {
						break;
					}
					Data data = new Data(random.nextInt(1000));
					System.out.println("生产了产品：" + data);
					synchronized (queue) {
						if (queue.size() >= size) {
							queue.notifyAll();
							queue.wait();
						} else {
							queue.add(data);
						}
					}
					Thread.sleep(random.nextInt(SLEEPTIME));
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
				Thread.currentThread().interrupt();
			}
	}
	
}
  • 消费者
package com.zjl.concurrent;

import java.util.List;
import java.util.Random;

public class Consumer implements Runnable {

	private List<Data> queue;
	private static final int SLEEPTIME = 1000;

	public Consumer(List<Data> queue) {
		this.queue = queue;
	}

	@Override
	public void run() {
		try {
			Random random = new Random();
			while (true) {
				if (Thread.currentThread().isInterrupted()) {
					break;
				}
				Data data = null;
				synchronized (queue) {
					if (queue.size() == 0) {
						queue.notifyAll();
						queue.wait();
					} else {
						data = queue.remove(0);
						System.out.println("消费者消费了：" + data);						
					}
				}
				Thread.sleep(random.nextInt(SLEEPTIME));
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}
  • 测试类
package com.zjl.concurrent;

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

public class QueueTest {

	public static void main(String[] args) throws InterruptedException {
		List<Data> queue = new ArrayList<>();
		Producer p1 = new Producer(queue, 10);
		Producer p2 = new Producer(queue, 10);
		Consumer c1 = new Consumer(queue);
		Consumer c2 = new Consumer(queue);
		ExecutorService service = Executors.newCachedThreadPool();
		service.execute(p1);
		service.execute(p2);
		service.execute(c1);
		service.execute(c2);
	}
}
  • 运行效果
生产了产品：Data [value=554]
生产了产品：Data [value=149]
生产了产品：Data [value=499]
生产了产品：Data [value=713]
消费者消费了：Data [value=554]
生产了产品：Data [value=447]
生产了产品：Data [value=106]
生产了产品：Data [value=463]
消费者消费了：Data [value=149]
消费者消费了：Data [value=499]
生产了产品：Data [value=568]
生产了产品：Data [value=336]
生产了产品：Data [value=32]
消费者消费了：Data [value=713]
生产了产品：Data [value=786]
消费者消费了：Data [value=447]
生产了产品：Data [value=254]
生产了产品：Data [value=697]
生产了产品：Data [value=78]
消费者消费了：Data [value=106]
消费者消费了：Data [value=463]
消费者消费了：Data [value=568]
生产了产品：Data [value=638]
生产了产品：Data [value=412]
消费者消费了：Data [value=336]
消费者消费了：Data [value=32]
生产了产品：Data [value=296]
生产了产品：Data [value=905]
生产了产品：Data [value=199]
生产了产品：Data [value=365]

总结：

  • 添加进集合操作用synchronized块来实现：

集合满容量时：唤醒其他线程，释放锁。

不满时直接添加进集合。

  • 消费时，删除操作也要用synchronized块来实现:

集合为空时：唤醒其他线程，释放锁。

不空时直接删除。

子非鱼eva
关注
专栏目录
BlockingQueue（阻塞队列）详解
weixin_30478923的博客
04-24 2808
注意：该随笔内容完全引自http://wsmajunfeng.iteye.com/blog/1629354，写的很好，非常感谢，复制过来算是个积累，怕以后找不到。 一. 前言 　　在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了Blo...
生产者消费者模式-Java实现
weixin_33796177的博客
03-03 502
感知阶段 　　　　随着软件业的发展，互联网用户的日渐增多，并发这门艺术的兴起似乎是那么合情合理。每日PV十多亿的淘宝，处理并发的手段可谓是业界一流。用户访问淘宝首页的平均等待时间只有区区几秒，但是服务器所处理的流程十分复杂。首先负责首页的服务器就有好几千台，通过计算把与用户路由最近的服务器处理首页的返回。其次是网页上的资源，就JS和CSS文件就有上百个，还有图片资源等。它能在几秒内加载出...
学习阻塞队列BlockingQueue
酒肉猿
06-21 453
学习阻塞（缓冲）队列BlockingQueue
JAVA并发提高篇—并发模型
麒麟阁
02-27 1467
多线程开发可以更好的发挥多核cpu性能，常用的多线程设计模式有：Future、Master-Worker、Guard Susperionsion（保护性暂挂模式）、不变模式、生产者-消费者 模式；jdk除了定义了若干并发的数据结构，也内置了多线程框架和各种线程池； 锁（分为内部锁、重入锁、读写锁）、ThreadLocal、信号量等在并发控制中发挥着巨大的作用。 一、F...
【多线程】Java中的阻塞队列（1）
qq_40939454的博客
02-23 133
一、阻塞队列 什么是阻塞队列？ 阻塞队列（BlockingQueue）是一个支持两个附加操作的队列，这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的队列会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。 二、BlockingQueue的核心方法 放入数据 offer（anObject）：表示如果可能的话，将anObject加到Bloc
labview 基于事件的生产者消费者模式
最新发布
03-17
labview 基于事件的生产者消费者模式
Java多线程生产者消费者模式实现过程解析
08-19
Java多线程生产者消费者模式实现过程解析 Java多线程生产者消费者模式是指在Java编程中，使用多线程来实现生产者和消费者之间的数据交换 и处理的模式。该模式下，生产者负责产生数据，而消费者负责处理数据。这种...
Java生产者消费者模式实例分析
08-26
Java生产者消费者模式实例分析 Java生产者消费者模式是一种常见的设计模式，它广泛应用于Java多线程编程中。该模式主要由三个部分组成：生产者、消费者和缓存。下面对Java生产者消费者模式的相关组成、原理及实现...
Lock、Condition实现简单的生产者消费者模式示例
09-04
在Java多线程编程中，生产者消费者模式是一种常见的设计模式，用于协调生产者线程和消费者线程之间的协作，确保资源的有效利用和同步。在这个示例中，使用了Java的`java.util.concurrent.locks`包中的`Lock`接口和`...
基于Java 生产者消费者模式(详细分析)
08-28
基于Java生产者消费者模式详细分析 一、生产者消费者模式概述 生产者消费者模式是多线程中最为常见的模式。生产者线程（一个或多个）生成面包放入篮子里（集合或数组），同时，消费者线程（一个或多个）从篮子里...
生产者与消费者分析
yiyongjiajun521的博客
08-04 2171
众所周知大型网站都是并发支持，用到最多的也是生产者与消费者模式。 生产消费者模型 　　　　生产者消费者模型具体来讲，就是在一个系统中，存在生产者和消费者两种角色，他们通过内存缓冲区进行通信，生产者生产消费者需要的资料，消费者把资料做成产品。 ，譬如注册用户这种服务，它可能解耦成好几种独立的服务（账号验证，邮箱验证码，手机短信码等）。它们作为消费者，等待用户输入数据，在前台数据提交之后会经过...
Java多线程-工具篇-BlockingQueue
weixin_30933531的博客
11-24 4001
前言： 在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。 认识BlockingQueue阻塞队列，顾名思义，首先它是一个队列，而一个...
如何实现生产者消费者模式
记录点滴的专栏
07-24 9226
生产/消费者问题是个非常典型的多线程问题，涉及到的对象包括“生产者”、“消费者”、“仓库”和“产品”。他们之间的关系如下： ① 生产者仅仅在仓储未满时候生产，仓满则停止生产。 ② 消费者仅仅在仓储有产品时候才能消费，仓空则等待。 ③ 当消费者发现仓库没产品可消费时候会通知生产者生产。 ④ 生产者在生产出可消费产品时候，应该通知等待的消费者去消费。 用wait/notify/notifyA
并发编程(13)-生产者消费者
jinjin603的博客
11-07 202
生产者和消费者是一个非常经典的多线程模式，我们在实际开发中应用非常广泛的思想理念。在生产-消费模式中：通常由两类线程，即若干个生产者的线程和若干个消费者的线程。生产者线程负责提交用户请求，消费者线程则负责具体处理生产者提交的任务，在生产者和消费者之间通过共享内存缓存区进行通信。 创建队列需要的data类： public final class Data { private S
使用java队列模拟生产者消费者
weixin_42548604的博客
08-21 243
生产者 public class ProducerThread implements Runnable { private BlockingQueue queue; private volatile boolean flag = true; private static AtomicInteger count = new AtomicInteger(); ...
创建自己的Queue底层实现是链表
红豆和绿豆的博客
10-11 813
package queueListedList; import java.util.LinkedList; import java.util.List; public class QLNode { private List list; public List getList() { return list; } public void set
[阻塞队列]BlockingQueue来实现简易的生产消费
新一的技术笔记
03-29 221
消费者： package com.dk.learndemo.queue; import java.util.Random; import java.util.concurrent.BlockingQueue; /** * @desc: Consumer * @date: 2021/3/29 3:34 下午 */ public class Consumer implements Runnable { private BlockingQueue<Data> queue;
生产者消费者问题（代码实现）
热门推荐
Csoul89757
07-19 1万+
生产者-消费者问题（也被称为有界缓冲器问题）是一个典型的例子多线程同步的问题。问题描述了两个进程，生产者和消费者，谁都有一个共同的，固定大小的缓冲区作为一个队列。制片人的工作是生成数据，把它放入缓冲区，并重新开始。同时，消费者在消费数据（即，从缓冲器中移除），一次一个块。问题是确保生产者不会尝试将数据添加到缓冲区，如果它的全部，而且消费者不会尝试从空缓冲区删除数据。 对生产者的解决方案是
Java生产者消费者模式实现详解
"Java生产者消费者模式的多种实现方法，包括使用synchronized和Object的wait、notifyAll方法，以及使用BlockingQueue。" 在Java中，生产者消费者模式是一种多线程设计模式，用于解决线程间的数据共享和同步问题。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值