线程（三）生产者消费者模型+POSIX信号量

生产者消费者模型

使用消费者模型的原因：

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

生产者消费者模型优点

• 解耦
• 支持并发
• 支持忙闲不均
  

基于BlockingQueue的生产者消费者模型

BlockingQueue

在多线程编程中阻塞队列(Blocking Queue)是一种常用于实现生产者和消费者模型的数据结构。其与普通的队列区别在于，当队列为空时，从队列获取元素的操作将会被阻塞，直到队列中被放入了元素；当队列满时，往队列里存放元素的操作也会被阻塞，直到有元素被从队列中取出(以上的操作都是基于不同的线程来说的，线程在对阻塞队列进程操作时会被阻塞)

Linux环境下C++ queue模拟阻塞队列的生产消费模型

#include <iostream>
#include <queue>
#include <stdlib.h>
#include <pthread.h>
 
#define NUM 8
 
class BlockQueue{
    private:
        std::queue<int> q;
        int cap;
        pthread_mutex_t lock;
        pthread_cond_t full;
        pthread_cond_t empty;
 
    private:
        void LockQueue()
        {
            pthread_mutex_lock(&lock);
        }
        void UnLockQueue()
        {
            pthread_mutex_unlock(&lock);
        }
        void ProductWait()
        {
            pthread_cond_wait(&full, &lock);
        }
        void ConsumeWait()
        {
            pthread_cond_wait(&empty, &lock);
        }
        void NotifyProduct()
        {
            pthread_cond_signal(&full);
        }
        void NotifyConsume()
        {
            pthread_cond_signal(&empty);
        }
        bool IsEmpty()
        {
            return ( q.size() == 0 ? true : false );
        }
        bool IsFull()
        {
            return ( q.size() == cap ? true : false );
            }
 
    public:
        BlockQueue(int _cap = NUM):cap(_cap)
        {
            pthread_mutex_init(&lock, NULL);
            pthread_cond_init(&full, NULL);
            pthread_cond_init(&empty, NULL);
        }
        void PushData(const int &data)
        {
            LockQueue();
            while(IsFull()){
                NotifyConsume();
                std::cout << "queue full, notify consume data, product stop." << 
std::endl;
                ProductWait();
            }
            q.push(data);
            UnLockQueue();
        }
        void PopData(int &data)
        {
            LockQueue();
            while(IsEmpty()){
                NotifyProduct();
                std::cout << "queue empty, notify product data, consume stop." << 
std::endl;
                ConsumeWait();
            }
            data = q.front();
            q.pop();
            UnLockQueue();
        }
        ~BlockQueue()
        {
            pthread_mutex_destroy(&lock);
            pthread_cond_destroy(&full);
            pthread_cond_destroy(&empty);
        }
};
 
void *consumer(void *arg)
{
    BlockQueue *bqp = (BlockQueue*)arg;
    int data;
    for( ; ; ){
        bqp->PopData(data);
        std::cout << "Consume data done : " << data << std::endl;
    }
}
void *producter(void *arg)
{
    BlockQueue *bqp = (BlockQueue*)arg;
    srand((unsigned long)time(NULL));
    for( ; ; ){
        int data = rand() % 1024;
        bqp->PushData(data);
        std::cout << "Prodoct data done: " << data << std::endl;
    }
}
 
int main()
{
    BlockQueue bq;
    pthread_t c,p;
    pthread_create(&c, NULL, consumer, (void*)&bq);
    pthread_create(&p, NULL, producter, (void*)&bq);
 
    pthread_join(c, NULL);
    pthread_join(p, NULL);
    return 0;
}

POSIX信号量

POSIX信号量和SystemV信号量作用相同，都是用于同步操作，达到无冲突的访问共享资源目的。 但POSIX可以用于线程间同步。

初始化信号量

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
参数：
    pshared:0表示线程间共享，非零表示进程间共享
    value：信号量初始值

销毁信号量

int sem_destroy(sem_t *sem);

等待信号量

功能：等待信号量，会将信号量的值减1
int sem_wait(sem_t *sem);

发布信号量

功能：发布信号量，表示资源使用完毕，可以归还资源了。将信号量值加1。
int sem_post(sem_t *sem);

基于环形队列的生产消费模型

• 环形队列采用数组模拟，用模运算来模拟环状特性
  
• 环形结构起始状态和结束状态都是一样的，不好判断为空或者为满，所以可以通过加计数器或者标记位来判断满或者空。另外也可以预留一个空的位置，作为满的状态
  

Linux环境下POSIX信号量环状队列的生产消费模型

#include <iostream>
#include <vector>
#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
 
#define NUM 16
 
class RingQueue{
    private:
        std::vector<int> q;
        int cap;
        sem_t data_sem;
        sem_t space_sem;
        int consume_step;
        int product_step;
 
    public:
        RingQueue(int _cap = NUM):q(_cap),cap(_cap)
        {
            sem_init(&data_sem, 0, 0);
            sem_init(&space_sem, 0, cap);
            consume_step = 0;
            product_step = 0;
        }
        void PutData(const int &data)
        {
            sem_wait(&space_sem); // P
            q[consume_step] = data;
            consume_step++;
            consume_step %= cap;
            sem_post(&data_sem); //V
        }
        void GetData(int &data)
        {
            sem_wait(&data_sem);
            data = q[product_step];
            product_step++;
            product_step %= cap;
            sem_post(&space_sem);
        }
        ~RingQueue()
        {
            sem_destroy(&data_sem);
            sem_destroy(&space_sem);
        }
};
void *consumer(void *arg)
{
    RingQueue *rqp = (RingQueue*)arg;
    int data;
    for( ; ; ){
        rqp->GetData(data);
        std::cout << "Consume data done : " << data << std::endl;
        sleep(1);
    }
}
 
//more faster
void *producter(void *arg)
{
    RingQueue *rqp = (RingQueue*)arg;
    srand((unsigned long)time(NULL));
    for( ; ; ){
        int data = rand() % 1024;
        rqp->PutData(data);
        std::cout << "Prodoct data done: " << data << std::endl;
    //  sleep(1);
    }
}
 
int main()
{
    RingQueue rq;
    pthread_t c,p;
    pthread_create(&c, NULL, consumer, (void*)&rq);
    pthread_create(&p, NULL, producter, (void*)&rq);
 
    pthread_join(c, NULL);
    pthread_join(p, NULL);
}