C++11 实现生产者消费者模式
代码都类似，看懂一个，基本都能理解了。
共有代码：
#include <cstdlib>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
static const int kItemRepositorySize = 10; // Item buffer size.
static const int kItemsToProduce = 1000; // How many items we plan to produce.
std::mutex mutex;//多线程标准输出同步锁
单生产者单消费者模式：
struct ItemRepository
{
int item_buffer[kItemRepositorySize]; // 产品缓冲区, 配合 read_position 和 write_position 模型环形队列.
size_t read_position; // 消费者读取产品位置.
size_t write_position; // 生产者写入产品位置.
std::mutex mtx; // 互斥量,保护产品缓冲区
std::condition_variable repo_not_full; // 条件变量, 指示产品缓冲区不为满.
std::condition_variable repo_not_empty; // 条件变量, 指示产品缓冲区不为空.
} gItemRepository; // 产品库全局变量, 生产者和消费者操作该变量. typedef struct ItemRepository ItemRepository; void ProduceItem(ItemRepository * ir, int item)
{
std::unique_lock<std::mutex> lock(ir->mtx);
while (((ir->write_position + ) % kItemRepositorySize)
== ir->read_position)
{ // item buffer is full, just wait here.
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "缓冲区满，等待缓冲区不满\n";
}
(ir->repo_not_full).wait(lock); // 生产者等待"产品库缓冲区不为满"这一条件发生.
} (ir->item_buffer)[ir->write_position] = item; // 写入产品.
(ir->write_position)++; // 写入位置后移. if (ir->write_position == kItemRepositorySize) // 写入位置若是在队列最后则重新设置为初始位置.
ir->write_position = ; (ir->repo_not_empty).notify_all(); // 通知消费者产品库不为空.
lock.unlock(); // 解锁.
} int ConsumeItem(ItemRepository *ir)
{
int data;
std::unique_lock<std::mutex> lock(ir->mtx);
// item buffer is empty, just wait here.
while (ir->write_position == ir->read_position)
{
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "缓冲区空，等待生产者生成产品\n";
}
(ir->repo_not_empty).wait(lock); // 消费者等待"产品库缓冲区不为空"这一条件发生.
} data = (ir->item_buffer)[ir->read_position]; // 读取某一产品
(ir->read_position)++; // 读取位置后移 if (ir->read_position >= kItemRepositorySize) // 读取位置若移到最后，则重新置位.
ir->read_position = ; (ir->repo_not_full).notify_all(); // 通知消费者产品库不为满.
lock.unlock(); // 解锁. return data; // 返回产品.
} void ProducerTask() // 生产者任务
{
for (int i = ; i <= kItemsToProduce; ++i)
{
// sleep(1);
ProduceItem(&gItemRepository, i); // 循环生产 kItemsToProduce 个产品.
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "生产第 " << i << "个产品" << std::endl;
}
}
} void ConsumerTask() // 消费者任务
{
static int cnt = ;
while ()
{
std::this_thread::sleep_for(std::chrono::seconds());
int item = ConsumeItem(&gItemRepository); // 消费一个产品.
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "消费第" << item << "个产品" << std::endl;
}
if (++cnt == kItemsToProduce) break; // 如果产品消费个数为 kItemsToProduce, 则退出.
}
} void InitItemRepository(ItemRepository *ir)
{
ir->write_position = ; // 初始化产品写入位置.
ir->read_position = ; // 初始化产品读取位置.
} void test()
{
InitItemRepository(&gItemRepository);
std::thread producer(ProducerTask); // 创建生产者线程.
std::thread consumer(ConsumerTask); // 创建消费之线程. producer.join();
consumer.join();
}
单生产者多消费者模式：
struct ItemRepository
{
int item_buffer[kItemRepositorySize];
size_t read_position;
size_t write_position;
size_t item_counter;
std::mutex mtx;
std::mutex item_counter_mtx;
std::condition_variable repo_not_full;
std::condition_variable repo_not_empty;
} gItemRepository; typedef struct ItemRepository ItemRepository; void ProduceItem(ItemRepository *ir, int item)
{
std::unique_lock<std::mutex> lock(ir->mtx);
while (((ir->write_position + ) % kItemRepositorySize)
== ir->read_position)
{
// item buffer is full, just wait here.
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "缓冲区满，等待缓冲区不满\n";
}
(ir->repo_not_full).wait(lock);
} (ir->item_buffer)[ir->write_position] = item;
(ir->write_position)++; if (ir->write_position == kItemRepositorySize)
ir->write_position = ; (ir->repo_not_empty).notify_all();
lock.unlock();
} int ConsumeItem(ItemRepository *ir)
{
int data;
std::unique_lock<std::mutex> lock(ir->mtx);
// item buffer is empty, just wait here.
while (ir->write_position == ir->read_position)
{
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "缓冲区空，等待生产者生产产品\n";
}
(ir->repo_not_empty).wait(lock);
} data = (ir->item_buffer)[ir->read_position];
(ir->read_position)++; if (ir->read_position >= kItemRepositorySize)
ir->read_position = ; (ir->repo_not_full).notify_all();
lock.unlock(); return data;
} void ProducerTask()
{
for (int i = ; i <= kItemsToProduce; ++i)
{
std::this_thread::sleep_for(std::chrono::milliseconds());
ProduceItem(&gItemRepository, i);
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "生产线程" << std::this_thread::get_id()
<< "生产第" << i << "个产品" << std::endl;
}
}
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "生产线程" << std::this_thread::get_id()
<< "退出" << std::endl;
}
} void ConsumerTask()
{
bool ready_to_exit = false;
while ()
{
// std::this_thread::sleep_for(std::chrono::milliseconds(6));
std::unique_lock<std::mutex> lock(gItemRepository.item_counter_mtx);
if (gItemRepository.item_counter < kItemsToProduce)
{
int item = ConsumeItem(&gItemRepository);
++(gItemRepository.item_counter);
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "消费线程" << std::this_thread::get_id()
<< "正在消费第" << item << "个产品" << std::endl;
}
}
else
{
ready_to_exit = true;
}
lock.unlock(); if (ready_to_exit == true)
{
break;
}
}
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "消费线程" << std::this_thread::get_id()
<< "退出" << std::endl;
}
} void InitItemRepository(ItemRepository *ir)
{
ir->write_position = ;
ir->read_position = ;
ir->item_counter = ;
} void test()
{
InitItemRepository(&gItemRepository);
std::thread producer(ProducerTask);
std::thread consumer1(ConsumerTask);
std::thread consumer2(ConsumerTask);
std::thread consumer3(ConsumerTask);
std::thread consumer4(ConsumerTask); producer.join();
consumer1.join();
consumer2.join();
consumer3.join();
consumer4.join();
}
多消费者单生产者模式：
struct ItemRepository
{
int item_buffer[kItemRepositorySize];
size_t read_position;
size_t write_position;
size_t item_counter;
std::mutex mtx;
std::mutex item_counter_mtx;
std::condition_variable repo_not_full;
std::condition_variable repo_not_empty;
} gItemRepository; typedef struct ItemRepository ItemRepository; void ProduceItem(ItemRepository *ir, int item)
{
std::unique_lock<std::mutex> lock(ir->mtx);
while (((ir->write_position + ) % kItemRepositorySize)
== ir->read_position)
{
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "缓冲区满，等待缓冲区不满\n";
}
(ir->repo_not_full).wait(lock);
} (ir->item_buffer)[ir->write_position] = item;
(ir->write_position)++; if (ir->write_position == kItemRepositorySize)
ir->write_position = ; (ir->repo_not_empty).notify_all();
lock.unlock();
} int ConsumeItem(ItemRepository *ir)
{
int data;
std::unique_lock<std::mutex> lock(ir->mtx);
// item buffer is empty, just wait here.
while (ir->write_position == ir->read_position)
{
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "消费者等待产品中。。。\n";
}
(ir->repo_not_empty).wait(lock);
} data = (ir->item_buffer)[ir->read_position];
(ir->read_position)++; if (ir->read_position >= kItemRepositorySize)
ir->read_position = ; (ir->repo_not_full).notify_all();
lock.unlock(); return data;
} void ProducerTask()
{
bool ready_to_exit = false;
while ()
{
std::this_thread::sleep_for(std::chrono::milliseconds());
std::unique_lock<std::mutex> lock(gItemRepository.item_counter_mtx);
if (gItemRepository.item_counter < kItemsToProduce)
{
++(gItemRepository.item_counter);
ProduceItem(&gItemRepository, gItemRepository.item_counter);
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "消费者" << std::this_thread::get_id()
<< "正在生产第" << gItemRepository.item_counter
<< "个产品" << std::endl;
}
}
else
{
ready_to_exit = true;
}
lock.unlock();
if (ready_to_exit == true) break;
}
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "消费者" << std::this_thread::get_id()
<< "退出" << std::endl;
}
} void ConsumerTask()
{
static int item_consumed = ;
while ()
{
std::this_thread::sleep_for(std::chrono::milliseconds());
++item_consumed;
if (item_consumed <= kItemsToProduce)
{
int item = ConsumeItem(&gItemRepository);
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "消费者" << std::this_thread::get_id()
<< "正在消费第" << item << "个产品" << std::endl;
}
}
else break;
}
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "消费者" << std::this_thread::get_id()
<< "退出" << std::endl;
}
} void InitItemRepository(ItemRepository *ir)
{
ir->write_position = ;
ir->read_position = ;
ir->item_counter = ;
} void test()
{
InitItemRepository(&gItemRepository);
std::thread producer1(ProducerTask);
std::thread producer2(ProducerTask);
std::thread producer3(ProducerTask);
std::thread producer4(ProducerTask);
std::thread consumer(ConsumerTask); producer1.join();
producer2.join();
producer3.join();
producer4.join();
consumer.join();
}
多消费者多生产者模式：
struct ItemRepository
{
int item_buffer[kItemRepositorySize];
size_t read_position;
size_t write_position;
size_t produced_item_counter;
size_t consumed_item_counter;
std::mutex mtx;
std::mutex produced_item_counter_mtx;
std::mutex consumed_item_counter_mtx;
std::condition_variable repo_not_full;
std::condition_variable repo_not_empty;
} gItemRepository; typedef struct ItemRepository ItemRepository; void ProduceItem(ItemRepository *ir, int item)
{
std::unique_lock<std::mutex> lock(ir->mtx);
while (((ir->write_position + ) % kItemRepositorySize)
== ir->read_position)
{
// item buffer is full, just wait here.
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "缓冲区满，生产者等待中\n";
}
(ir->repo_not_full).wait(lock);
} (ir->item_buffer)[ir->write_position] = item;
(ir->write_position)++; if (ir->write_position == kItemRepositorySize)
ir->write_position = ; (ir->repo_not_empty).notify_all();
lock.unlock();
} int ConsumeItem(ItemRepository *ir)
{
int data;
std::unique_lock<std::mutex> lock(ir->mtx);
// item buffer is empty, just wait here.
while (ir->write_position == ir->read_position)
{
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "缓冲区空，消费者等待中\n";
}
(ir->repo_not_empty).wait(lock);
} data = (ir->item_buffer)[ir->read_position];
(ir->read_position)++; if (ir->read_position >= kItemRepositorySize)
ir->read_position = ; (ir->repo_not_full).notify_all();
lock.unlock(); return data;
} void ProducerTask()
{
bool ready_to_exit = false;
while ()
{
std::this_thread::sleep_for(std::chrono::milliseconds());
std::unique_lock<std::mutex> lock(gItemRepository.produced_item_counter_mtx);
if (gItemRepository.produced_item_counter < kItemsToProduce)
{
++(gItemRepository.produced_item_counter);
ProduceItem(&gItemRepository, gItemRepository.produced_item_counter);
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "生产者" << std::this_thread::get_id()
<< "正在生产第" << gItemRepository.produced_item_counter
<< "个产品" << std::endl;
}
}
else
{
ready_to_exit = true;
} lock.unlock();
if (ready_to_exit == true)
{
break;
}
}
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "生产者" << std::this_thread::get_id()
<< "退出" << std::endl;
}
} void ConsumerTask()
{
bool ready_to_exit = false;
while ()
{
std::this_thread::sleep_for(std::chrono::milliseconds());
std::unique_lock<std::mutex> lock(gItemRepository.consumed_item_counter_mtx);
if (gItemRepository.consumed_item_counter < kItemsToProduce)
{
int item = ConsumeItem(&gItemRepository);
++(gItemRepository.consumed_item_counter);
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "消费者" << std::this_thread::get_id()
<< "正在消费第" << item << "个产品" << std::endl;
}
}
else
{
ready_to_exit = true;
}
lock.unlock();
if (ready_to_exit == true)
{
break;
}
}
{
std::lock_guard<std::mutex> lock(mutex);
std::cout << "消费者" << std::this_thread::get_id()
<< "退出" << std::endl;
}
} void InitItemRepository(ItemRepository *ir)
{
ir->write_position = ;
ir->read_position = ;
ir->produced_item_counter = ;
ir->consumed_item_counter = ;
} void test()
{
InitItemRepository(&gItemRepository);
std::thread producer1(ProducerTask);
std::thread producer2(ProducerTask);
std::thread producer3(ProducerTask);
std::thread producer4(ProducerTask); std::thread consumer1(ConsumerTask);
std::thread consumer2(ConsumerTask);
std::thread consumer3(ConsumerTask);
std::thread consumer4(ConsumerTask); producer1.join();
producer2.join();
producer3.join();
producer4.join(); consumer1.join();
consumer2.join();
consumer3.join();
consumer4.join();
}
注：
1、当缓存容量为n时，其实只能存放n-1个产品，主要原因是，当缓存满和空时，用取余无法区分
2、当单单模式变成多多模式时，只是针对单变多的某一方多添加一个读写锁
3、向标准缓冲区输出字符串时，由于是多线程的，所以需要使用读写锁来同步
完整实例下载：http://files.cnblogs.com/files/swarmbees/Producer_Consumer.zip
如果您觉得文章不错，不妨给个打赏，写作不易，感谢各位的支持。您的支持是我最大的动力，谢谢！！！
 |
 |
很重要--转载声明
- 本站文章无特别说明，皆为原创，版权所有，转载时请用链接的方式，给出原文出处。同时写上原作者：朝十晚八 or Twowords
- 如要转载，请原文转载，如在转载时修改本文，请事先告知，谢绝在转载时通过修改本文达到有利于转载者的目的。
C++11 实现生产者消费者模式的更多相关文章
- python 并发编程 锁 / 信号量 / 事件 / 队列(进程间通信（IPC）) /生产者消费者模式
(1)锁:进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,而共享带来的是竞争,竞争带来的结果就是错乱,如何控制,就是加锁处理. 虽然使用加锁的形式实现了 ...
- 基于Java 生产者消费者模式(详细分析)
Java 生产者消费者模式详细分析 本文目录:1.等待.唤醒机制的原理2.Lock和Condition3.单生产者单消费者模式4.使用Lock和Condition实现单生产单消费模式5.多生产多消费模 ...
- 2.5多线程（Java学习笔记）生产者消费者模式
一.什么是生产者消费者模式 生产者生产数据存放在缓冲区,消费者从缓冲区拿出数据处理. 可能大家会问这样有何好处? 1.解耦 由于有了缓冲区,生产者和消费者之间不直接依赖,耦合度降低,便于程序拓展和维护 ...
- wait、notify应用场景（生产者-消费者模式）
Java实现生产者消费者的方式有:wait && notify.BlockingQueue.Lock && Condition等 wait.notify注意事项:(1) ...
- 第三节: List类型的介绍、生产者消费者模式、发布订阅模式
一. List类型基础 1.介绍 它是一个双向链表,支持左进.左出.右进.右出,所以它即可以充当队列使用,也可以充当栈使用. (1). 队列:先进先出, 可以利用List左进右出,或者右进左出(Lis ...
- java多线程 生产者消费者模式
package de.bvb; /** * 生产者消费者模式 * 通过 wait() 和 notify() 通信方法实现 * */ public class Test1 { public static ...
- LabVIEW之生产者/消费者模式--队列操作 彭会锋
LabVIEW之生产者/消费者模式--队列操作 彭会锋 本文章主要是对学习LabVIEW之生产者/消费者模式的学习笔记,其中涉及到同步控制技术-队列.事件.状态机.生产者-消费者模式,这几种技术在在本 ...
- 转：Task任务调度实现生产者消费者模式 (个人理解后文)
纯属个人愚见.欢迎加入反驳(PiDou). 1.前文大致就是,利用Queue配置的一个TaskFactory任务调度器.实现生产者消费者模式的例子..首先我就试了 第一种 FIFO(先进先出)的配置. ...
- Lucene.net站内搜索—4、搜索引擎第一版技术储备（简单介绍Log4Net、生产者消费者模式）
目录 Lucene.net站内搜索—1.SEO优化 Lucene.net站内搜索—2.Lucene.Net简介和分词Lucene.net站内搜索—3.最简单搜索引擎代码Lucene.net站内搜索—4 ...
随机推荐
- pycharm的list的应用
li = [11,22,22,33,44] v = li.count(22) print (v) #输出结果2 #计算元素的次数 count的应用 li = [11,22,33,22,44] li.e ...
- Shell脚本学习 - 运算符
继续shell脚本学习.上一篇是基本数据类型和语法的总结,这一篇是运算相关的操作. 运算符 bash不支持简单的数学计算,需要依赖其他命令实现. expr可以代为实现. # 表达式一般这么写 ` + ...
- BZOJ.4137.[FJOI2015]火星商店问题(线段树分治 可持久化Trie)
BZOJ 洛谷 一直觉得自己非常zz呢.现在看来是真的=-= 注意题意描述有点问题,可以看BZOJ/洛谷讨论. 每个询问有两个限制区间,一是时间限制\([t-d+1,t]\),二是物品限制\([L,R ...
- 虚拟环境更新HA
停止HA服务 sudo systemctl stop homeassistant@homeassistant 开始更新HA sudo -u homeassistant -H -s cd /srv/ho ...
- XIX Open Cup named after E.V. Pankratiev. GP of Poland(AMPPZ-2018)
A. Drone With a Camera 三分套三分. #include<cstdio> #include<cmath> #include<algorithm> ...
- 编程菜鸟的日记-初学尝试编程-C++ Primer Plus 第6章编程练习5
#include <iostream> using namespace std; const double N1=35000; const int N2=15000; const int ...
- JS for循环 if判断、white循环。小练习二
假设一个简单的ATM机的取款过程是这样的:首先提示用户输入密码(password),最多只能输入三次,超过3次则提示用户“密码错误,请取卡”结束交易.如果用户密码正确,再提示用户输入取款金额(amou ...
- idea设置调用方法时提示方法注释
如图所示:打开file-->setting-->Editor-->General,搜索show,然后勾选上Show quick documentation on mouse move ...
- NOIP-比例简化
题目描述 在社交媒体上,经常会看到针对某一个观点同意与否的民意调查以及结果.例如,对某一观点表示支持的有 1498 人,反对的有 902 人,那么赞同与反对的比例可以简单的记为 1498:902 . ...
- SpringCloud 在Feign上使用Hystrix（断路由）
SpringCloud 在Feign上使用Hystrix(断路由) 第一步:由于Feign的起步依赖中已经引入了Hystrix的依赖,所以只需要开启Hystrix的功能,在properties文件中 ...