Linux中的生产者消费者模型

为什么要使用生产者消费者模型

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

要满足生产着消费者模型必须有：3种关系、2类角色和一个交易场所，可以简单记为321原则

3种关系：

• 生产者-生产者：互斥关系
• 消费者-消费者：互斥关系
• 生产者-消费者：互斥、同步关系

2类角色：生产者、消费者

1个交易场所：缓冲区

生产者消费者模型的优点

• 解耦合：降低生产者和消费者之间的关联关系
• 支持并发
• 支持忙闲不均

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

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

以单消费者、单生产者为例，模拟实现生产着消费者模型：

queue.hpp
#pragma once
#include <iostream>
#include <queue>
#include <pthread.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.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 ConsumerWait()
        {
            pthread_cond_wait(&empty,&lock);//队列为空,消费者等待并释放锁
        }
        void NotifyProducter()
        {
            pthread_cond_signal(&full);//唤醒在full的条件变量下等待的生产者
        }
        void NotifyConsumer()
        {
            pthread_cond_signal(&empty);//唤醒在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())
            {
                NotifyConsumer();//通知消费者消费
                std::cout << "queue is full,notify consumer ,product stop." << std::endl;
                ProductWait();
            }
            q.push(data);
            NotifyConsumer();//一旦有数据就唤醒消费者
            UnLockQueue();
        }
        //删除队列中的数据
        void PopData(int &data)
        {
            LockQueue();
            while(IsEmpty())
            {
                NotifyProducter();//通知生产者生产
                std::cout << "queue is empty,notify product,consumer stop." << std::endl;
                ConsumerWait();
            }
            data = q.front();
            q.pop();
            NotifyProducter();//一旦有空间就通知生产者生产
            UnLockQueue();
        }
        ~BlockQueue()
        {
            pthread_mutex_destroy(&lock);
            pthread_cond_destroy(&full);
            pthread_cond_destroy(&empty);
        }
};

queue.cc
#include "queue.hpp"
#include <time.h>
void* consumer(void* arg)
{
    BlockQueue *bq = (BlockQueue*)arg;
    int data;
    for(;;)
    {
        bq->PopData(data);
        std::cout << "Consume data done : " << data << std::endl;
    }
}
void* producter(void* arg)//arg中存放的是阻塞队列的首地址
{
    BlockQueue *bq = (BlockQueue*)arg;
    srand((unsigned long)time(NULL));
    for(;;)
    {
        int data = rand() % 1024;
        bq->PushData(data);
        std::cout << "Product data done: " << std::endl;
    }
}
int main()
{
    BlockQueue bq;
    pthread_t c,p;//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;
}

生产者-消费者是基于queue的，其空间可以动态分配。

POSIX信号量

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

初始化信号量

#include <semaphore.h>

int sem_init(sem_t *sem,int pshared,unsigned int value);

参数:

pshared:0表示线程间共享,非零表示进程间共享

value:信号量初始

销毁信号量

int sem_destroy(sem_t *sem);

等待信号量(P操作)

功能：等待信号量，会将信号量的值减1

int sem_wait(sem_t *sem);

发布信号量(V操作)

功能：发布信号量，表示资源使用完毕，可以归还资源了。将资源信号量值加1

int sem_post(sem_t *sem);

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

• 环形队列采用数组模拟，用模运算来模拟环状特性
• 环形结构起始状态和结束状态都是一样的，不好判断为空或为满，所有可以通过计数器或者标记位来判断满或空。另外也可以预留一个空的位置，作为满的状态。
• 我们现在基于信号量这个计数器，就很简单的进行多线程间的同步过程。

环形队列的生产者消费者案例：

circlequeue.hpp
#pragma once
#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);
        }
};

circlequeue.cc
#include "circlequeue.hpp"
#include <unistd.h>

void* producter(void* arg)
{
    RingQueue *rq = (RingQueue*)arg;
    srand((unsigned long)time(NULL));
    for(;;)
    {
        int data = rand() % 1024;
        rq->PutData(data);
        std::cout << "Product data done: " << data << std::endl;
        sleep(1);
    }
}
void* consumer(void* arg)
{
    RingQueue *rq = (RingQueue*)arg;
    int data;
    for(;;)
    {
        rq->GetData(data);
        std::cout << "Consume 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);
}

读写者问题

读写锁

在编写多线程的时候，有一种情况是十分常见的，即有些公共数据修改的机会比较少，相比较改写，它们读的机会反而高得多。通常而言，在读数据的过程中，往往伴随着查找的操作，中间耗时很长。给这种代码段加锁，会极大的降低我们程序的效率。因此，我们必须用一种方法，专门处理这种多读少写的情况。这种方法就是读写锁。

读写锁的行为

当前状态	读锁请求	写锁请求
无锁	可以	可以
读锁	可以	阻塞
写锁	阻塞	阻塞

从表格中得出的结论是：写独占，读共享，写锁优先级高

读者-写者模型：读者不会把数据读走，这是和生产者-消费者模型本质的区别。

读-写关系：同步和互斥。同步关系中分为读优先和写优先。读者与读者之间是共享关系，写者与写者之间是互斥关系。

读写锁相关接口

设置读写优先

int pthread_rwlockattr_setkind_np(pthread_rwlockattr_t *attr,int pref);

pref有三种选择：

PTHREAD_RWLOCK_PREFER_READER_NP（设置默认）读者优先，可能会导致写者饥饿情况

PTHREAD_RWLOCK_PREFER_WRITER_NP写者优先，但目前有bug，导致表现行为和PTHREAD_RWLOCK_PREFER_READER_NP一致

PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP写者优先，但写者不能递归加锁

初始化

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t *restrict attr);

销毁

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

枷锁和解锁

//加锁
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthrwad_rwlock_t *rwlock);
//解锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);