ToB企服应用市场:ToB评测及商务社交产业平台

标题: 信号量——Linux并发之魂 [打印本页]
作者: 盛世宏图    时间: 2024-7-11 14:48
标题: 信号量——Linux并发之魂

   接待来到 破晓的历程的 博客  

弁言

今天，我们继承学习Linux线程天职，在Linux条件变量中，我们对条件变量的做了具体的阐明，今天我们要利用条件变量来引出我们的另一个话题——信号量内容的学习。
1.复习条件变量

在上一期博客中，我们没有对条件变量做具体的使用，所以，这里我们通过一份代码来复习一下，接下来，我们实现基于BlockingQueue的生产者消费者模型。
1.1何为基于BlockingQueue的生产者消费者模型

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

1.2分析该模型

这里我想写多个生产线程和多个消费线程的模型
我们来分析一下。
  1. template<class T>
  2. class BlockQueue
  3. {
  4. public:
  5.     BlockQueue(const int &maxcap=gmaxcap):_maxcap(maxcap)
  6.     {
  7.         pthread_mutex_init(&_mutex,nullptr);
  8.         pthread_cond_init(&_pcond,nullptr);
  9.         pthread_cond_init(&_ccond,nullptr);
  11.     }
  12.     void push(const T&in)//输入型参数，const &
  13.     {
  14.         pthread_mutex_lock(&_mutex);
  15.         while(is_full())
  16.         {
  17.             pthread_cond_wait(&_pcond,&_mutex);
  19.         }
  20.         _q.push(in);
  22.         pthread_cond_signal(&_ccond);
  23.         pthread_mutex_unlock(&_mutex);
  24.     }
  25.     void pop(T*out)
  26.     {
  27.         pthread_mutex_lock(&_mutex);
  28.         while(is_empty())
  29.         {
  30.             pthread_cond_wait(&_ccond,&_mutex);
  31.         }
  32.         *out=_q.front();
  33.         _q.pop();
  34.         pthread_cond_signal(&_pcond);
  35.         pthread_mutex_unlock(&_mutex);
  36.     }
  37.     ~BlockQueue()
  38.     {
  39.         pthread_mutex_destroy(&_mutex);
  40.         pthread_cond_destroy(&_ccond);
  41.         pthread_cond_destroy(&_pcond);
  42.     }
  43. private:
  44.     bool is_empty()
  45.     {
  46.         return _q.empty();
  47.     }
  48.     bool is_full()
  49.     {
  50.         return _q.size()==_maxcap;
  51.     }
  52. private:
  53.     std::queue<T> _q;
  54.     int _maxcap; //队列中元素的上线
  55.     pthread_mutex_t _mutex;
  56.     pthread_cond_t _pcond; //生产者对应的条件变量
  57.     pthread_cond_t _ccond;
  58. };
复制代码
由于我们不知道存储的数据类型，所以这里我们选择使用泛型编程的方式。
接下来就是要生产任务，为了可以观察到整个生产和消费任务的过程，我们可以生成两个随机数，然后进行运算。代码如下：
  1. class CalTask
  2. {
  3.     using func_t = function<int(int, int, char)>;
  5. public:
  6.     CalTask() {}
  7.     CalTask(int x, int y, char op, func_t func)
  8.         :_x(x),_y(y),_op(op),_callback(func)
  9.     {}
  10.     string  operator()()
  11.     {
  12.         int result=_callback(_x,_y,_op);
  13.         char buffer[1024];
  14.         snprintf(buffer,sizeof buffer,"%d %c %d=%d",_x,_op,_y,result);
  15.         return buffer;
  16.     }
  17.     string toTaskstring()
  18.     {
  19.         char buffer[1024];
  20.         snprintf(buffer,sizeof buffer,"%d %c %d=?",_x,_op,_y);
  21.         return buffer;
  22.     }   
  23. private:
  24.     int _x;
  25.     int _y;
  26.     char _op;
  27.     func_t _callback;
  28. };
  29. const char*oper="+-*/%";
  30. int mymath(int x,int y,char op)
  31. {
  32.     int result=0;
  33.     switch(op)
  34.     {
  35.         case '+':
  36.             result=x+y;
  37.             break;
  38.         case '-':
  39.             result=x-y;
  40.             break;
  41.         case '*':
  42.             result=x*y;
  43.             break;
  44.         case '/':
  45.             if(y==0)
  46.             {
  47.                 cerr<<"div zero error"<<endl;
  48.                 result=-1;
  49.             }
  50.             else
  51.             {
  52.                 result=x/y;
  53.             }
  54.             break;
  55.         case '%':
  56.             if(y==0)
  57.             {
  58.                 cerr<<"mod zero error"<<endl;
  59.                 result=-1;
  61.             }
  62.             else
  63.             {
  64.                 result=x%y;
  65.             }
  66.         default:
  67.             break;
  68.     }
  69.     return result;
  70. }
复制代码
接下来，我们来写整体的代码。
1.3完备代码

我们要创建三个文件：BlockQueue.hpp Task.hpp Main.cc各文件内容如下所示：
BlockQueue.hpp
  1. #pragma once#include<iostream>#include<pthread.h>#include<cstring>#include<unistd.h>#include<cassert>#include<queue>using namespace  std;const int gmaxcap=100;template<class T>
  2. class BlockQueue
  3. {
  4. public:
  5.     BlockQueue(const int &maxcap=gmaxcap):_maxcap(maxcap)
  6.     {
  7.         pthread_mutex_init(&_mutex,nullptr);
  8.         pthread_cond_init(&_pcond,nullptr);
  9.         pthread_cond_init(&_ccond,nullptr);
  11.     }
  12.     void push(const T&in)//输入型参数，const &
  13.     {
  14.         pthread_mutex_lock(&_mutex);
  15.         while(is_full())
  16.         {
  17.             pthread_cond_wait(&_pcond,&_mutex);
  19.         }
  20.         _q.push(in);
  22.         pthread_cond_signal(&_ccond);
  23.         pthread_mutex_unlock(&_mutex);
  24.     }
  25.     void pop(T*out)
  26.     {
  27.         pthread_mutex_lock(&_mutex);
  28.         while(is_empty())
  29.         {
  30.             pthread_cond_wait(&_ccond,&_mutex);
  31.         }
  32.         *out=_q.front();
  33.         _q.pop();
  34.         pthread_cond_signal(&_pcond);
  35.         pthread_mutex_unlock(&_mutex);
  36.     }
  37.     ~BlockQueue()
  38.     {
  39.         pthread_mutex_destroy(&_mutex);
  40.         pthread_cond_destroy(&_ccond);
  41.         pthread_cond_destroy(&_pcond);
  42.     }
  43. private:
  44.     bool is_empty()
  45.     {
  46.         return _q.empty();
  47.     }
  48.     bool is_full()
  49.     {
  50.         return _q.size()==_maxcap;
  51.     }
  52. private:
  53.     std::queue<T> _q;
  54.     int _maxcap; //队列中元素的上线
  55.     pthread_mutex_t _mutex;
  56.     pthread_cond_t _pcond; //生产者对应的条件变量
  57.     pthread_cond_t _ccond;
  58. };
复制代码
Task.hpp
  1. #pragma once
  2. #include <iostream>
  3. #include <string>
  4. #include <cstdio>
  5. #include<string>
  6. #include <functional>
  7. using namespace std;
  8. class CalTask
  9. {
  10.     using func_t = function<int(int, int, char)>;
  12. public:
  13.     CalTask() {}
  14.     CalTask(int x, int y, char op, func_t func)
  15.         :_x(x),_y(y),_op(op),_callback(func)
  16.     {}
  17.     string  operator()()
  18.     {
  19.         int result=_callback(_x,_y,_op);
  20.         char buffer[1024];
  21.         snprintf(buffer,sizeof buffer,"%d %c %d=%d",_x,_op,_y,result);
  22.         return buffer;
  23.     }
  24.     string toTaskstring()
  25.     {
  26.         char buffer[1024];
  27.         snprintf(buffer,sizeof buffer,"%d %c %d=?",_x,_op,_y);
  28.         return buffer;
  29.     }   
  30. private:
  31.     int _x;
  32.     int _y;
  33.     char _op;
  34.     func_t _callback;
  35. };
  36. const char*oper="+-*/%";
  37. int mymath(int x,int y,char op)
  38. {
  39.     int result=0;
  40.     switch(op)
  41.     {
  42.         case '+':
  43.             result=x+y;
  44.             break;
  45.         case '-':
  46.             result=x-y;
  47.             break;
  48.         case '*':
  49.             result=x*y;
  50.             break;
  51.         case '/':
  52.             if(y==0)
  53.             {
  54.                 cerr<<"div zero error"<<endl;
  55.                 result=-1;
  56.             }
  57.             else
  58.             
  59.                            result=x/y;
  60.             }
  61.             break;
  62.         case '%':
  63.             if(y==0)
  64.             {
  65.                 cerr<<"mod zero error"<<endl;
  66.                 result=-1;
  67.             }
  68.             else
  69.             {
  70.                 result=x%y;
  71.             }
  72.         default:
  73.             break;
  74.     }
  75.     return result;
  76. }
复制代码
Main.cc
  1. include "BlockQueue.hpp"
  2. #include "Task.hpp"
  3. #include<sys/types.h>
  4. #include<unistd.h>
  5. #include<ctime>
  6. #include<iostream>
  7. using namespace std;
  10. void *productor(void *bqs_)
  11. {
  12.     BlockQueue<CalTask> *bqs=static_cast<BlockQueue<CalTask>*>(bqs_);
  13.     while(true)
  14.     {
  15.         int x=rand()%10+1;
  16.         int y=rand()%5+1;
  17.         int opercode=rand()%(sizeof(oper));
  18.         CalTask T(x,y,oper[opercode],mymath);
  19.         bqs->push(T);
  20.         cout<<"生产任务: ";
  21.         cout<<T.toTaskstring()<<endl;
  22.         sleep(1);
  23.     }
  24. }
  25. void *consumer(void *bqs_)
  26. {
  27.     BlockQueue<CalTask>*bqs=static_cast<BlockQueue<CalTask>*>(bqs_);
  28.     while(true)
  29.     {
  30.         CalTask T;
  31.         bqs->pop(&T);
  32.         cout<<"消费任务: ";
  33.         cout<<T()<<endl;
  35.     }
  36. }
  37. int main()
  38. {
  39.     BlockQueue<CalTask> bqs;
  40.     pthread_t p[5];
  41.     pthread_t c[5];
  42.     for(int i=0;i<5;i++)
  43.     {
  44.         pthread_create(&p[i],nullptr,productor,&bqs);
  45.         pthread_create(&c[i],nullptr,consumer,&bqs);
  46.     }
  47.     for(int i=0;i<5;i++)
  48.     {
  49.         pthread_join(p[i],nullptr);
  50.         pthread_join(c[i],nullptr);
  51.     }
  52. }
复制代码
在代码中，有几个点需要注意一下：
第一点：

pthread_cond_wait的第二个参数一定是我们正在使用的互斥锁，这个函数在被运行时，会以原子性的方式将锁开释，然后将自己挂起，等待被条件变量叫醒。该函数在被叫醒时，会自动重新获取持有的锁，然后继承向下执行。
如果数个生产者线程一起被叫醒，然后先后持有锁，接着继承生产任务，当队列剩余的空间小于这些生产者生产的任务时，就会出现问题，所以让所有被叫醒的线程先通过while循环，如果有剩余的空间，再进行任务的生产活动。
   生产线程这样处理，消费线程也要这样处理
  大家可以在自己试这敲一下，有问题可以在评论区和我交流。
接下来，我们来查找一下这些代码有哪些"不足的地方"
2.代码中的“不足”

一个线程在操纵临界资源时，临界资源必须是满意条件的，然后线程才能对临界资源进行操纵。比如：在如上代码中，生产者线程只有在队列(临界资源）有剩余空间的条件下，才能进行下一步操纵。
可是，临界资源是否满意生产和消费的条件，我们不能事前得知，只等进入临界资源后，再进行进一步的检测。
所以，一样平常访问临界资源的过程为：先加锁，再检测，如果条件满意，就进行下一步的操纵；反之，就将该线程挂起，开释锁，然后挂起等待，等到条件满意时，重新得到锁，接着进行下一步操纵。
因为不大概事先得知是否满意条件，所以我们只能先加锁，进入临界资源内部进行检测。
只要我们申请了信号量，就默认对这部分资源的整体使用，但通常环境下，我们使用的仅仅是临界资源的一小部分。
实际环境中，有没有大概差别的线程访问临界资源差别部分的环境，有大概。所以，先辈大佬们给出了一种办理方案——信号量。
3.信号量

3.1什么是信号量

信号量的本质是一把计数器，一把权衡临界资源多少的计数器。只要拥有信号量，就在未来一定能够拥有临界资源的一部分。
   申请信号量的本质：就是对临界资源的预定机制。
  比如：我想去看电影，首先我要买票。我一旦买到票，无论我去不去看电影，都会有一个位置属于我。买票的过程==申请信号信号量的过程。
所以，在访问临界资源之前，我们可以申请信号量。通过申请信号量，我们就可以获知临界资源的使用环境。①只要申请成功，就一定有我可以访问的资源。②只要申请失败，阐明条件不停当，只能等待。云云，就不需要进入临界资源再进行检测了。
3.2信号量的相关接口


如上这些捏词如果调用成功的话，返回0；调用失败的话，返回-1，并且错误原因被设置。
我们知道信号量的本质是一把计数器，所以信号量必须可以进行递增和递减的操纵。

3.3用信号量来实现基于环形队列的生产消费模型

3.3.1对环形队列的简单介绍

信任大家在C++学习期间到都模仿实现过环形队列队列。如图：

环形队列的逻辑结构为环形，但其存储结构实际上就是队列，实在就是一个数组，只不过用下标不停的%上队列的长度。
大家在模仿实现环形队列时，大家肯定碰到的问题是：当rear==front时，究竟是环形队列已满照旧环形队列为空呢？实在，这个问题有多种处理方式，今天就不讲了。
今天，我们的基于环形队列的生产消费模型必须服从哪些规则呢？
我们来讲一个故事：
张三和李四在一个房间里做游戏，这个房间里有一张大圆桌，桌子上有很多的盘子。规定张三往每个盘子里放一个桃子



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4