目录
1.什么是生产者消费者模型
它是时一个经典的多线程并发的协作模型,也就是生产者(线程)向一个公共区域(阻塞队列)生产,生产出的“商品”被消费者(线程)消费。
其中生产者可以拥有多个,消费者可以拥有多个,但是公共区域只有一个。
2. 生产者消费者模型的理解
2.1为什么要对公共区域做保护
公共区域也被称为临界区,都知道要对临界区做保护,但是为什么呢?
例:
1.生产者向公共区域生产的时候,刚生产了一半,就被消费者拿走了,这就造成了数据不一致的问题。
2.公共的区域是有一定的容量限制的,当公共区域只剩下一个空位的时候,第一个生产者看到有一个空位,准备生产,但是在刚要生产的时候,cpu切换到第二个线程,第二个线程也看到有一个空位,也准备生产,这就产生了过度生产的问题,同样消费也会过度消费。
所以公共区域只能由,同一时间只能一个线程访问(阻塞队列是这样的,其他的不一定)。
2.2角色之间的关系
生产者与生产者 (互斥关系)生产者想要生产就必要和其他生产者竞争一把锁,竞争到锁才能生产。
消费者与消费者 (互斥关系)生产者想要消费就必要和其他消费者竞争一把锁,竞争到锁才能消费。
生产者和消费者(同步&&互斥)无论生产还是消费都需要竞争锁(互斥),当生产者将公共区域生产满了,就需要消费者进行消费,不然生产者也无法继续生产(同步)。
2.3为什有生产者消费者模型、
1.因为它可以提供很好的并发度,在放任务和取任务是串行执行的,但是执行任务的时候时并行的。
2.生产和消费的数据解耦。
3.支持忙闲不均。
3.实现代码
blockqueue.hpp
#ifndef __BLOCKQUEUE__
#define __BLOCKQUEUE__
#include<queue>
#include<pthread.h>
template <class T>
class blockqueue
{
private:
bool isfull()
{
return _cap == _blockqueue.size();
}
bool isempty()
{
return _blockqueue.empty();
}
public:
blockqueue(int cap)
:_cap(cap)
{
pthread_mutex_init(&mutex,nullptr);
pthread_cond_init(&p_cond,nullptr);
pthread_cond_init(&c_cond,nullptr);
}
//生产者向队列里生产
void enqueue (T data)
{
pthread_mutex_lock(&mutex);
while(isfull())
{
pthread_cond_wait(&p_cond,&mutex);
}
_blockqueue.push(data);
//唤醒消费者 消费
pthread_cond_signal(&c_cond);
pthread_mutex_unlock(&mutex);
}
//消费者从队列里消费
void pop(T &data)
{
pthread_mutex_lock(&mutex);
while(isempty())
{
pthread_cond_wait(&c_cond,&mutex);
}
data = _blockqueue.front();
_blockqueue.pop();
//唤醒生产者
pthread_cond_signal(&p_cond);
pthread_mutex_unlock(&mutex);
}
~blockqueue()
{
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&p_cond);
pthread_cond_destroy(&c_cond);
}
private:
int _cap;//容量
std::queue<T> _blockqueue;
pthread_mutex_t mutex;//互斥锁
pthread_cond_t p_cond;//条件变量唤醒生产者生产
pthread_cond_t c_cond;//条件变量唤醒消费者消费
};
#endif
Main.cc
#include<thread>
#include<iostream>
#include<string>
#include<vector>
#include"blockqueue.hpp"
#include<unistd.h>
int a = 0;
void product(blockqueue<int>* bk)
{
while(true)
{
//sleep(2);
bk->enqueue(a);
std::cout<<"product a data " << a <<std::endl;
a++;
}
}
void consumer(blockqueue<int>* bk)
{
while(true)
{
sleep(1);
int date = 0;
bk->pop(date);
std::cout<<"consum a data " << date <<std::endl;
}
}
void ConsumerStart( blockqueue<int>* bk, std::vector<std::thread> &threads, int num)
{
for(int i = 0; i < num; i++)
{
threads.emplace_back(product, bk);
}
}
void ProductStart( blockqueue<int>* bk, std::vector<std::thread> &threads, int num)
{
for(int i = 0; i < num; i++)
{
threads.emplace_back(consumer, bk);
}
}
void waitall(std::vector<std::thread> &threads)
{
for(auto & thread : threads)
{
thread.join();
}
}
int main()
{
blockqueue<int>* bk = new blockqueue<int>(5);
std::vector<std::thread> threads;
ProductStart(bk, threads, 5);
ConsumerStart(bk, threads, 1);
waitall(threads);
delete bk;
return 0;
}
这份代码就是生产者生产一个整型变量,消费者接受之后打印出来。
这里也有一些小的问题需要注意
这里生产者生产的时候要判断,阻塞队列是否为满,满了就阻塞在pthread_cond_wait(&p_cond,&mutex); 这里为什么不用if判断呢?
线程在pthread_cond_wait(&p_cond,&mutex);这里等待,等待就必然要被唤醒。
如果用if被唤醒之后会直接向下执行,如果这时候阻塞队列是满的,在生产也就出问题了。
但是用while循环,被唤醒之后还会在判断一次队列是否为满,满就继续等待,这么写很好的增强了代码的健壮性。