• 基于循环队列和信号量的生产和消费者模型

    这一节为什么要基于信号量来实现同一个模型，原因：

    1.  void push(const T& in)
    2.     {
    3.         pthread_mutex_lock(&_lock);
    4.         while(is_Full())
    5.         {
    6.             //这里说明阻塞队列是满的，需要让生产者等待
    7.             pthread_cond_wait(&_pcond,&_lock);
    8.             
    9.         }
    10.         //这里说明阻塞队列至少有一个空位可以插入
    11.         _queue.push(in);
    12.         //唤醒消费者去消费
    13.         pthread_cond_signal(&_ccond);
    14.         pthread_mutex_unlock(&_lock);
    15.         
    16.     }

    在我们访问公共资源的时候，消费者需要竞争同一把锁，然后还要继续判断是否能在临界区中生产数据。如果竞争到了锁然后判断不能生产数据，则需要继续等待。竞争锁需要消耗时间，判断等待也需要，这就导致了程序效率的低下。因此信号量的存在就解决了这一个问题：在竞争锁之前就提前预知了临界资源是否就绪。

    POSIX信号量

    信号量就相当于一个计数器，计数了临界资源中资源的数目，接下来我们学习使用它的接口：

    初始化信号量

    #include
    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); //P()

    发布信号量

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

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

    引入循环队列

    循环队列是一个逻辑结构，是由数组演变而成。通过对数组的下标访问进行模运算变成一个循环访问，这就是循环队列。当消费者和生产者在同一位置时，可能循环队列为空，另一种可能就是生产者消费满了，消费者来不及消费。因此其余时间生产消费者都不在同一位置生产和消费数据。

    实现模型的三个必要条件

    1.生产者不能套消费者一圈。

    2.消费者不能超越生产者。

    3.如果生产者和消费者在同一个位置，队列为空让生产者先走，队列为满让消费者先走。

    引入信号量

    通过信号量我们可以预知知道队列中资源的数目，如果生产者套了消费者一圈，这时生产者就申请不到信号量，只有消费者能够申请，因此只有消费者可以消费，生产者必须等待。同理消费者把数据消费光和生产者在同一位置时，消费者申请不到信号量只有生产者可以，因此只有生产者可以生产而消费者必须等待，通过引入信号量满足了该模型的三个必要条件。

    代码实现

    简易版的代码实现：

    main.cc

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include "RingQueue.hpp"
    7.  
    8. using namespace std;
    9.  
    10. void *consumer(void *queue)
    11. {
    12.     RingQueue<int> *rq = static_castint> *>(queue);
    13.     while (true)
    14.     {
    15.         int result = 0;
    16.         rq->pop(&result);
    17.         cout << "消费者消费了一个数据：" << result << endl;
    18.         sleep(1);
    19.     }
    20. }
    21.  
    22. void *product(void *queue)
    23. {
    24.     RingQueue<int> *rq = static_castint> *>(queue);
    25.     while (true)
    26.     {
    27.         //(1);
    28.         int data = rand() % 10 + 1;
    29.         rq->push(data);
    30.         cout << "生产者生产了一个数据：" << data << endl;
    31.     }
    32. }
    33.  
    34. int main()
    35. {
    36.     srand((unsigned int)time(nullptr) ^ getpid() ^ 0x123456);
    37.     RingQueue<int> *rq = new RingQueue<int>();
    38.     pthread_t c, p;
    39.     pthread_create(&c, nullptr, consumer, (void *)rq);
    40.     pthread_create(&p, nullptr, product, (void *)rq);
    41.  
    42.     pthread_join(c, nullptr);
    43.     pthread_join(p, nullptr);
    44.     delete rq;
    45.     return 0;
    46. }

    RingQueue.hpp 

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. using namespace std;
    7.  
    8. static const int gcap = 6;
    9.  
    10. template <class T>
    11. class RingQueue
    12. {
    13.  
    14. private:
    15.     void P(sem_t *sem) // 申请信号量 --
    16.     {
    17.         int n = sem_wait(sem);
    18.         assert(n == 0);
    19.         (void)n;
    20.     }
    21.  
    22.     void V(sem_t *sem) // 释放信号量 ++
    23.     {
    24.         int n = sem_post(sem);
    25.         assert(n == 0);
    26.         (void)n;
    27.     }
    28.  
    29. public:
    30.     RingQueue(const int &cap = gcap) : _queue(cap), _cap(cap)
    31.     {
    32.  
    33.         int n = sem_init(&_spaceSem, 0, cap);
    34.         assert(n == 0);
    35.         int m = sem_init(&_dataSem, 0, 0);
    36.         assert(m == 0);
    37.         _productStep = _consumerStep = 0;
    38.     }
    39.  
    40.     void push(const T &in)
    41.     {
    42.         P(&_spaceSem); // 申请空间信号量
    43.         _queue[_productStep++] = in;
    44.         _productStep %= _cap;
    45.  
    46.         V(&_dataSem); // 释放数据信号量
    47.     }
    48.  
    49.     void pop(T *out)
    50.     {
    51.         P(&_dataSem);
    52.         *out = _queue[_consumerStep++];
    53.         _consumerStep %= _cap;
    54.  
    55.         V(&_spaceSem);
    56.     }
    57.  
    58.     ~RingQueue()
    59.     {
    60.         sem_destroy(&_spaceSem);
    61.         sem_destroy(&_dataSem);
    62.     }
    63.  
    64. private:
    65.     std::vector _queue;
    66.     int _cap;
    67.     sem_t _spaceSem;
    68.     sem_t _dataSem;
    69.     int _productStep;
    70.     int _consumerStep;
    71. };

    引入计算任务：

    Task.hpp

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. class CalTask
    6. {
    7. public:
    8.     using func_t = std::function<int(int, int, char)>;
    9.  
    10.     CalTask() {}
    11.  
    12.     CalTask(int x, int y, char op, func_t func) : _x(x), _y(y), _op(op), _callback(func)
    13.     {
    14.     }
    15.  
    16.     std::string operator()()
    17.     {
    18.         int result = _callback(_x, _y, _op);
    19.         char buffer[64];
    20.         snprintf(buffer, sizeof buffer, "%d %c %d =%d", _x, _op, _y, result);
    21.         return buffer;
    22.     }
    23.  
    24.     std::string to_string()
    25.     {
    26.         char buffer[64];
    27.         snprintf(buffer, sizeof buffer, "%d %c %d = ?", _x, _op, _y);
    28.         return buffer;
    29.     }
    30.  
    31.     ~CalTask()
    32.     {
    33.     }
    34.  
    35. private:
    36.     int _x;
    37.     int _y;
    38.     char _op;
    39.     func_t _callback;
    40. };
    41.  
    42. int mymath(int x, int y, char op)
    43. {
    44.     int result = 0;
    45.     switch (op)
    46.     {
    47.     case '+':
    48.         result = x + y;
    49.         break;
    50.     case '-':
    51.         result = x - y;
    52.         break;
    53.     case '*':
    54.         result = x * y;
    55.         break;
    56.  
    57.     case '/':
    58.         if (y == 0)
    59.         {
    60.             std::cerr << "div zero error" << std::endl;
    61.             break;
    62.         }
    63.         result = x / y;
    64.         break;
    65.  
    66.     case '%':
    67.         if (y == 0)
    68.         {
    69.             std::cerr << "mod zero error" << std::endl;
    70.             break;
    71.         }
    72.         result = x % y;
    73.         break;
    74.     }
    75.     return result;
    76. }

    RingQueue.hpp

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. using namespace std;
    8.  
    9. static const int gcap = 6;
    10. static const string symbol ="+-*/%";
    11.  
    12. template <class T>
    13. class RingQueue
    14. {
    15.  
    16. private:
    17.     void P(sem_t *sem) // 申请信号量 --
    18.     {
    19.         int n = sem_wait(sem);
    20.         assert(n == 0);
    21.         (void)n;
    22.     }
    23.  
    24.     void V(sem_t *sem) // 释放信号量 ++
    25.     {
    26.         int n = sem_post(sem);
    27.         assert(n == 0);
    28.         (void)n;
    29.     }
    30.  
    31. public:
    32.     RingQueue(const int &cap = gcap) : _queue(cap), _cap(cap)
    33.     {
    34.  
    35.         int n = sem_init(&_spaceSem, 0, cap);
    36.         assert(n == 0);
    37.         int m = sem_init(&_dataSem, 0, 0);
    38.         assert(m == 0);
    39.         _productStep = _consumerStep = 0;
    40.     }
    41.  
    42.     void push(const T &in)
    43.     {
    44.         P(&_spaceSem); // 申请空间信号量
    45.         _queue[_productStep++] = in;
    46.         _productStep %= _cap;
    47.  
    48.         V(&_dataSem); // 释放数据信号量
    49.     }
    50.  
    51.     void pop(T *out)
    52.     {
    53.         P(&_dataSem);
    54.         *out = _queue[_consumerStep++];
    55.         _consumerStep %= _cap;
    56.  
    57.         V(&_spaceSem);
    58.     }
    59.  
    60.     ~RingQueue()
    61.     {
    62.         sem_destroy(&_spaceSem);
    63.         sem_destroy(&_dataSem);
    64.     }
    65.  
    66. private:
    67.     std::vector _queue;
    68.     int _cap;
    69.     sem_t _spaceSem;
    70.     sem_t _dataSem;
    71.     int _productStep;
    72.     int _consumerStep;
    73. };

    main.cc

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include "RingQueue.hpp"
    7. #include "Task.hpp"
    8.  
    9. using namespace std;
    10.  
    11. void *consumer(void *queue)
    12. {
    13.     RingQueue *rq = static_cast *>(queue);
    14.     while (true)
    15.     {
    16.         CalTask result ;
    17.         rq->pop(&result);
    18.         cout << "消费者处理了一个任务：" << result() << endl;
    19.         sleep(1);
    20.     }
    21. }
    22.  
    23. void *product(void *queue)
    24. {
    25.     RingQueue *rq = static_cast *>(queue);
    26.     while (true)
    27.     {
    28.         int x =rand()%10;
    29.         int y =rand()%10;
    30.         char op =symbol[rand()%symbol.size()];
    31.         CalTask t(x,y,op, mymath);
    32.         rq->push(t);
    33.         cout << "生产者生产了一个任务：" << t.to_string() << endl;
    34.     }
    35. }
    36.  
    37. int main()
    38. {
    39.     srand((unsigned int)time(nullptr) ^ getpid() ^ 0x123456);
    40.     RingQueue *rq = new RingQueue();
    41.     pthread_t c, p;
    42.     pthread_create(&c, nullptr, consumer, (void *)rq);
    43.     pthread_create(&p, nullptr, product, (void *)rq);
    44.  
    45.     pthread_join(c, nullptr);
    46.     pthread_join(p, nullptr);
    47.     delete rq;
    48.     return 0;
    49. }

    多线程多并发执行：

    想要实现多线程并发的进行消费和生产，我们只需要保证临界资源的访问安全，因此我们可以在访问临界资源的时候加上锁：

    但是这么加锁有一个问题：当我们申请锁成功后才能申请信号量，锁只有一把需要多个线程竞争后才能交付并且申请信号量也需要花费时间。因此我们可以先申请信号量，让多个线程先预定好共享资源中的资源，然后再申请锁进行临界资源的访问，这样做提高了程序的效率。

    最终代码：

    1. //RingQueue.hpp
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. using namespace std;
    10.  
    11. static const int gcap = 6;
    12. static const string symbol ="+-*/%";
    13.  
    14. template <class T>
    15. class RingQueue
    16. {
    17.  
    18. private:
    19.     void P(sem_t *sem) // 申请信号量 --
    20.     {
    21.         int n = sem_wait(sem);
    22.         assert(n == 0);
    23.         (void)n;
    24.     }
    25.  
    26.     void V(sem_t *sem) // 释放信号量 ++
    27.     {
    28.         int n = sem_post(sem);
    29.         assert(n == 0);
    30.         (void)n;
    31.     }
    32.  
    33. public:
    34.     RingQueue(const int &cap = gcap) : _queue(cap), _cap(cap)
    35.     {
    36.  
    37.         int n = sem_init(&_spaceSem, 0, cap);
    38.         assert(n == 0);
    39.         int m = sem_init(&_dataSem, 0, 0);
    40.         assert(m == 0);
    41.         _productStep = _consumerStep = 0;
    42.         pthread_mutex_init(&_pmutex,nullptr);
    43.         pthread_mutex_init(&_cmutex,nullptr);
    44.  
    45.     }
    46.  
    47.     void push(const T &in)
    48.     {
    49.         P(&_spaceSem); // 申请空间信号量
    50.         pthread_mutex_lock(&_pmutex);
    51.         _queue[_productStep++] = in;
    52.         _productStep %= _cap;
    53.         pthread_mutex_unlock(&_pmutex);
    54.  
    55.         V(&_dataSem); // 释放数据信号量
    56.         
    57.  
    58.     }
    59.  
    60.     void pop(T *out)
    61.     {
    62.         
    63.         P(&_dataSem);
    64.         pthread_mutex_lock(&_cmutex);
    65.         *out = _queue[_consumerStep++];
    66.         _consumerStep %= _cap;
    67.         pthread_mutex_unlock(&_cmutex);
    68.         
    69.         V(&_spaceSem);
    70.     
    71.     }
    72.  
    73.     ~RingQueue()
    74.     {
    75.         sem_destroy(&_spaceSem);
    76.         sem_destroy(&_dataSem);
    77.         pthread_mutex_destroy(&_pmutex);
    78.         pthread_mutex_destroy(&_cmutex);
    79.  
    80.     }
    81.  
    82. private:
    83.     std::vector _queue;
    84.     int _cap;
    85.     sem_t _spaceSem;
    86.     sem_t _dataSem;
    87.     int _productStep;
    88.     int _consumerStep;
    89.     pthread_mutex_t _pmutex;
    90.     pthread_mutex_t _cmutex;
    91. };
    92.  
    93. //Task.hpp
    94.  
    95. #include 
    96. #include 
    97. #include 
    98.  
    99. class CalTask
    100. {
    101. public:
    102.     using func_t = std::function<int(int, int, char)>;
    103.  
    104.     CalTask() {}
    105.  
    106.     CalTask(int x, int y, char op, func_t func) : _x(x), _y(y), _op(op), _callback(func)
    107.     {
    108.     }
    109.  
    110.     std::string operator()()
    111.     {
    112.         int result = _callback(_x, _y, _op);
    113.         char buffer[64];
    114.         snprintf(buffer, sizeof buffer, "%d %c %d =%d", _x, _op, _y, result);
    115.         return buffer;
    116.     }
    117.  
    118.     std::string to_string()
    119.     {
    120.         char buffer[64];
    121.         snprintf(buffer, sizeof buffer, "%d %c %d = ?", _x, _op, _y);
    122.         return buffer;
    123.     }
    124.  
    125.     ~CalTask()
    126.     {
    127.     }
    128.  
    129. private:
    130.     int _x;
    131.     int _y;
    132.     char _op;
    133.     func_t _callback;
    134. };
    135.  
    136. int mymath(int x, int y, char op)
    137. {
    138.     int result = 0;
    139.     switch (op)
    140.     {
    141.     case '+':
    142.         result = x + y;
    143.         break;
    144.     case '-':
    145.         result = x - y;
    146.         break;
    147.     case '*':
    148.         result = x * y;
    149.         break;
    150.  
    151.     case '/':
    152.         if (y == 0)
    153.         {
    154.             std::cerr << "div zero error" << std::endl;
    155.             break;
    156.         }
    157.         result = x / y;
    158.         break;
    159.  
    160.     case '%':
    161.         if (y == 0)
    162.         {
    163.             std::cerr << "mod zero error" << std::endl;
    164.             break;
    165.         }
    166.         result = x % y;
    167.         break;
    168.     }
    169.     return result;
    170. }
    171.  
    172. //main.cc
    173.  
    174. #include 
    175. #include 
    176. #include 
    177. #include 
    178. #include 
    179. #include "RingQueue.hpp"
    180. #include "Task.hpp"
    181.  
    182. using namespace std;
    183.  
    184. string SelfName()
    185. {
    186.     char name[64];
    187.     snprintf(name,sizeof name,"thread[0x%x]",pthread_self());
    188.     return name;
    189. }
    190.  
    191. void *consumer(void *queue)
    192. {
    193.     RingQueue *rq = static_cast *>(queue);
    194.     while (true)
    195.     {
    196.         CalTask result ;
    197.         rq->pop(&result);
    198.         cout << SelfName()<<"消费者处理了一个任务：" << result() << endl;
    199.         sleep(1);
    200.     }
    201. }
    202.  
    203. void *product(void *queue)
    204. {
    205.     RingQueue *rq = static_cast *>(queue);
    206.     while (true)
    207.     {
    208.         int x =rand()%10;
    209.         int y =rand()%10;
    210.         char op =symbol[rand()%symbol.size()];
    211.         CalTask t(x,y,op, mymath);
    212.         rq->push(t);
    213.         cout << SelfName()<<"生产者生产了一个任务：" << t.to_string() << endl;
    214.     }
    215. }
    216.  
    217. int main()
    218. {
    219.     srand((unsigned int)time(nullptr) ^ getpid() ^ 0x123456);
    220.     RingQueue *rq = new RingQueue();
    221.     pthread_t c[10], p[6];
    222.     for(int i =0;i<10;++i)pthread_create(c+i, nullptr, consumer, (void *)rq);
    223.     for(int i =0;i<6;++i)pthread_create(p+i, nullptr, product, (void *)rq);
    224.  
    225.     for(int i =0;i<10;++i)pthread_join(c[i], nullptr);
    226.     for(int i =0;i<6;++i)pthread_join(p[i], nullptr);
    227.     
    228.     delete rq;
    229.     return 0;
    230. }

    这里所说的消费者和生产者模型的高效性和上一节基于阻塞队列的是一样的，如果不清楚的话可以点击《基于阻塞队列的生产和消费模型》进行复习！！！到这里生产者和消费者模型讲解就结束了，下一节我们学习线程池，敬请期待!!!!!记得点赞多多支持喔！！！

  • 相关阅读:
    完整目标检测项目流程——从使用LabelImg标注到使用YOLOv5训练测试
    图形学-(视图变换,投影变换)
    【云原生】一文带你吃透FlexManager数据传入华为云IOT
    大模型改变了NLP的游戏规则了吗
    Linux 文件/目录管理
    2022最新调优、微服务、框架、分布式指南，我的“大厂”不是梦
    CleanClip for Mac 剪切板 粘贴工具 历史记录 安装（保姆级教程，新手小白轻松上手）
    备份和恢复Gitlab数据
    thinkphp6（tp6）创建定时任务
    【C++】vector 的常用接口
  • 原文地址：https://blog.csdn.net/m0_69005269/article/details/132698705