LINUX系统编程：基于阻塞队列的生产者消费者模型

目录

1.什么是生产者消费者模型

2. 生产者消费者模型的理解

2.1为什么要对公共区域做保护

2.2角色之间的关系

2.3为什有生产者消费者模型、

3.实现代码

blockqueue.hpp

Main.cc

---

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循环，被唤醒之后还会在判断一次队列是否为满，满就继续等待，这么写很好的增强了代码的健壮性。