【Linux】基于 环形队列 的生产者消费者模型（C++）

1. 前言

环形队列的生产者-消费者模型 是一种常用的并发编程模式，主要用于协调生产者和消费者之间的任务处理。简单介绍如下：

1. 环形队列： 这是一个固定大小的缓冲区，队列的末端与起始端相连，形成一个环。队列通常有两个指针：一个指向队列的头部（消费者操作）和一个指向队列的尾部（生产者操作）。

2. 生产者： 生产者负责生成数据并将其放入队列。生产者在队列未满时，将数据写入尾部，并更新尾指针。当队列满时，生产者需要等待。

3. 消费者： 消费者从队列中取出数据进行处理。消费者在队列非空时，从头部取出数据，并更新头指针。当队列为空时，消费者需要等待。

4. 同步机制： 为了防止生产者和消费者的操作冲突，通常使用互斥锁（mutex）和条件变量（condition variable）来同步对环形队列的访问，确保线程安全。

工作流程：

• 生产者生成数据后，将数据插入队列，并通知消费者。
• 消费者从队列中取出数据进行处理，并可能通知生产者继续生产。

---

2. 环形队列

对于数据结构，我们通常有两个重要概念：物理结构 和 逻辑结构

物理结构（Physical Structure）：物理结构描述数据在计算机内存或存储介质中的实际存储方式。

逻辑结构（Logical Structure）：逻辑结构描述数据之间的逻辑关系，即数据的逻辑组织方式。

对于环形队列来说：

其物理结构为数组：数组的大小通常是固定的，根据队列的容量确定。每个数组元素存储一个队列元素。通过数组的索引来表示队首和队尾的位置。

逻辑结构即：

线性结构：环形队列可以被看作是一种线性结构，因为元素在队列中是按顺序排列的。即使数组是环形的，我们仍然可以从队首到队尾以线性的方式遍历所有元素。

循环性质：环形队列具有循环性质，即队尾指针可以回到队首形成一个环。这意味着当队尾指针到达数组末尾时，它可以回到数组的起始位置，利用数组中未使用的空间。

---

3. 生产者消费者模型

生产者消费者模型 是一种常用的 并发编程模型 ，用于解决多线程或多进程环境下的协作问题。该模型包含两类角色：生产者和消费者。

生产者负责生成数据，并将数据存放到共享的缓冲区中。消费者则从缓冲区中获取数据并进行处理。生产者和消费者之间通过共享的缓冲区进行数据交互。

为了确保线程安全，生产者和消费者需要遵循一些规则：

1. 如果缓冲区已满，则生产者需要等待直到有空间可用。
2. 如果缓冲区为空，则消费者需要等待直到有数据可用。
3. 生产者和消费者都不能访问缓冲区的内部结构，只能通过特定的接口进行操作。

---

4. 实现思路

上述

根据图示：

a. 生产者不能将消费者套圈：当队列为空时，生产者先 生产元素，当绕过环形队列一圈后，生产者和消费者指向同一位置，此时不能让生产者继续生产元素。

b. 消费者不能超过生产者：消费者消费的数据量一定要 <= 生产者，不然哪有多出的部分用来消费？？

c. 为空时，生产者先运行：当队列为空，消费者无数据可以消费，自然要生产者先运行。

d. 为满时，消费者先运行：同理前者，当队列为满，不能让生产者继续生产，让消费者先消费数据。

我们该如何通过编码 来保证这些条件？

首先我们要知道：在操作系统中，信号量（Semaphore） 通常提供两个基本操作，即 P（wait）操作 和 V（signal） 操作。

• P 操作（也称为 wait 操作）用于获取或等待信号量。其作用是将信号量的值减1，如果结果小于0，则表示资源不可用，当前线程需要被阻塞等待其他线程释放资源。P 操作可以阻塞线程，直到获得信号量为止。
• V 操作（也称为 signal 操作）用于释放信号量。其作用是将信号量的值加1。如果有线程因为等待信号量而处于阻塞状态，那么 V 操作可以唤醒其中一个等待的线程，使其继续执行。

根据图示：我们已经实现了基本逻辑，其可以保证 abcd四则条件的成立

a. 生产者不能将消费者套圈：生产者生产完毕后执行 V(dataSem) 操作，释放了资源信号量，然后消费者才进行申请资源信号量，消费后释放了空间资源，即实现了生产者消费者的同步。

b. 消费者不能超过生产者：消费者会根据申请到的数据资源进行特定位置的消费，不会进行多余操作，保证其不超过生产者。

c. 为空时，生产者先运行：队列为空时，消费者执行的P(dataSem)操作并不会申请到数据，此时生产者P(spaceSem)可以正确执行

d. 为满时，消费者先运行：同理c，队列为满，生产者P(spaceSem)不会成功申请到空闲空间，只有消费者可以先运行。

---

代码实现

sem.hpp（信号量）

该生产消费者模型中 信号量的作用：

从实现思路 中我们知道 为了实现线程同步，保证上面四则条件，这里进行信号量类的定义。

// 信号
#ifndef _SEM_HPP // 防止重复包含头文件
// 如果未定义_SEM_HPP，则执行下面的代码
#define _SEM_HPP

#include <iostream>
#include <semaphore.h>

class Sem
{
public:
    Sem(int value) // 构造
    {
        sem_init(&_sem, 0, value);
    }

    void p() // 对信号进行 p操作（等待操作
    {
        sem_wait(&_sem);
    }

    void v() // 对信号执行 v操作（释放资源
    {
        sem_post(&_sem);
    }
    
    ~Sem()  // 析构: 销毁信号
    {
        sem_destroy(&_sem);
    }

private:
    sem_t _sem;
};

#endif

---

RingQueue.hpp（环形队列）

环形队列的实现包含以下成员变量：

std::vector<T> _ring_queue; // 物理结构: 数组
int _num; // 当前元素个数
int c_step; // 生产者下标
int p_step; // 消费者下标

Sem _space_sem; // 空间信号量，表示可用空闲缓冲区数
Sem _data_sem; // 数据信号量，表示当前已生产的产品数
pthread_mutex_t clock; // 互斥锁，用于保护 c_step 的访问
pthread_mutex_t plock; // 互斥锁，用于保护 p_step 的访问

完整代码

// 环形队列
#ifndef _Ring_QUEUE_HPP_ // 防止重复包含
#define _Ring_QUEUE_HPP_ // 如果此前未定义_Ring_QUEUE_HPP_，执行下列代码

#include <iostream>
#include <vector>
#include <pthread.h>
#include "sem.hpp"

const int g_default_num = 5; // 默认存储元素个数设为5

// 多线程
template<class T>
class RingQueue
{
public:
    // 构造
    RingQueue(int default_num = g_default_num)
        :_ring_queue(default_num),
        _num(default_num),
        c_step(0),
        p_step(0),
        _space_sem(default_num),
        _data_sem(0)
    {
        pthread_mutex_init(&clock, nullptr); // 初始化互斥锁
        pthread_mutex_init(&plock, nullptr);   
    }

    // 析构
    ~RingQueue()
    {
        pthread_mutex_destroy(&clock); // 销毁互斥锁
        pthread_mutex_destroy(&plock);
    }

    // 生产者进程: 将指定元素放入队列
    void push(const T& in)
    {
        // 先申请信号量
        _space_sem.p(); // 等待信号
        pthread_mutex_lock(&plock); // 加锁

        _ring_queue[p_step++] = in; // 生产数据: 将in给环形队列，生产者下标++
        p_step %= _num; // 实现环形结构

        pthread_mutex_unlock(&plock); // 解锁
        _data_sem.v(); // 销毁信号
    }

    // 消费者进程: 从队列中取出元素
    void pop(T* out)
    {
        // 多个消费者线程可能会竞争修改 c_step 的值
        // 通过互斥锁 保护对 c_step 的访问
        // 只有成功竞争到互斥锁的消费者线程才能修改 
        _data_sem.p();
        pthread_mutex_lock(&clock);
        *out = _ring_queue[c_step++]; // 
        c_step %= _num;
        
        pthread_mutex_unlock(&clock);
        _space_sem.v();
    }

private:
    std::vector<T> _ring_queue; // 物理结构: 数组
    int _num; // 当前元素个数
    int c_step; // 生产者下标
    int p_step; // 消费者下标

    Sem _space_sem; // 空间信号量，表示可用空闲缓冲区数
    Sem _data_sem; // 数据信号量，表示当前已生产的产品数
    pthread_mutex_t clock; // 互斥锁，用于保护 c_step 的访问
    pthread_mutex_t plock; // 互斥锁，用于保护 p_step 的访问
};

#endif

ConPro.cc（生产者消费者主函数）

// 生产者消费者模型;

#include "RingQueue.hpp"
#include <cstdlib>
#include <ctime>
#include <sys/types.h>
#include <unistd.h>

void* consumer(void* args)
{
    RingQueue<int>* rq = (RingQueue<int>*)args; // 将传入的参数转为RingQueue<int>* 类型，以便执行后续操作

    while(true)
    {
        sleep(1);
        int x;
        // 从环形队列中换取 任务/数据
        rq->pop(&x);
        // 执行操作
        std::cout << "消费者: " << x << " [" << pthread_self() << "]" << std::endl;
    }
}

void* productor(void* args)
{
    RingQueue<int>* rq = (RingQueue<int>*)args; 

    while(true)
    {
        // 创建 任务对象/数据，可以从外部获取，也可以由生产者生产
        int x = rand() % 100 + 1;
        std::cout << "生产者: " << x << " [" << pthread_self() << "]" << std::endl;

        // 推送到环形队列
        rq->push(x); // 执行生产操作
    }
}

int main()
{
    srand((uint64_t)time(nullptr) ^ getpid());
    RingQueue<int> *rq = new RingQueue<int>();
    //
    pthread_t c[3], p[2]; // 两个生产者，三个消费者
    // 创建消耗者进程
    pthread_create(&c[0], nullptr, consumer, (void*)rq);
    pthread_create(&c[1], nullptr, consumer, (void*)rq);
    pthread_create(&c[2], nullptr, consumer, (void*)rq);
    // 创建生产者进程
    pthread_create(&p[0], nullptr, productor, (void*)rq);
    pthread_create(&p[1], nullptr, productor, (void*)rq);

    for(int i = 0; i < 3; ++i)
        pthread_join(c[i], nullptr);

    for(int i = 0; i < 2; ++i)
        pthread_join(p[i], nullptr);

    return 0;
}