devbox
喵喵爱编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

信号量——Linux并发之魂

作者：喵喵爱编程 | 2024-07-10 19:07:25

赞

踩

信号量——Linux并发之魂

欢迎来到 破晓的历程的 博客

引言

今天，我们继续学习Linux线程本分，在Linux条件变量中，我们对条件变量的做了详细的说明，今天我们要利用条件变量来引出我们的另一个话题——信号量内容的学习。

1.复习条件变量

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

1.1何为基于BlockingQueue的生产者消费者模型

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

1.2分析该模型

这里我想写多个生产线程和多个消费线程的模型
我们来分析一下。

  1. 首先生产任务的过程和消费任务的过程必须是互斥关系，不可以同时访问该队列（此时，这个队列是共享资源）。
  2. 当队列满时，生产线程就不能再生产任务，必须在特定的条件变量下等待；同理当队列为空时，消费线程就不能再消费任务，也必须在特定的条件变量下等待。
    所以，类应这样设计：
template<class T>
class BlockQueue
{
public:
    BlockQueue(const int &maxcap=gmaxcap):_maxcap(maxcap)
    {
        pthread_mutex_init(&_mutex,nullptr);
        pthread_cond_init(&_pcond,nullptr);
        pthread_cond_init(&_ccond,nullptr);

    }
    void push(const T&in)//输入型参数，const &
    {
        pthread_mutex_lock(&_mutex);
        while(is_full())
        {
            pthread_cond_wait(&_pcond,&_mutex);

        }
        _q.push(in);

        pthread_cond_signal(&_ccond);
        pthread_mutex_unlock(&_mutex);
    }
    void pop(T*out)
    {
        pthread_mutex_lock(&_mutex);
        while(is_empty())
        {
            pthread_cond_wait(&_ccond,&_mutex);
        }
        *out=_q.front();
        _q.pop();
        pthread_cond_signal(&_pcond);
        pthread_mutex_unlock(&_mutex);
    }
    ~BlockQueue()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_ccond);
        pthread_cond_destroy(&_pcond);
    }
private:
    bool is_empty()
    {
        return _q.empty();
    }
    bool is_full()
    {
        return _q.size()==_maxcap;
    }
private:
    std::queue<T> _q;
    int _maxcap; //队列中元素的上线
    pthread_mutex_t _mutex;
    pthread_cond_t _pcond; //生产者对应的条件变量
    pthread_cond_t _ccond;
};

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58

由于我们不知道存储的数据类型，所以这里我们选择使用泛型编程的方式。
接下来就是要生产任务，为了可以观察到整个生产和消费任务的过程，我们可以生成两个随机数，然后进行运算。代码如下：

class CalTask
{
    using func_t = function<int(int, int, char)>;

public:
    CalTask() {}
    CalTask(int x, int y, char op, func_t func) 
        :_x(x),_y(y),_op(op),_callback(func)
    {}
    string  operator()()
    {
        int result=_callback(_x,_y,_op);
        char buffer[1024];
        snprintf(buffer,sizeof buffer,"%d %c %d=%d",_x,_op,_y,result);
        return buffer;
    }
    string toTaskstring()
    {
        char buffer[1024];
        snprintf(buffer,sizeof buffer,"%d %c %d=?",_x,_op,_y);
        return buffer;
    }   
private:
    int _x;
    int _y;
    char _op;
    func_t _callback;
};
const char*oper="+-*/%";
int mymath(int x,int y,char op)
{
    int result=0;
    switch(op)
    {
        case '+':
            result=x+y;
            break;
        case '-':
            result=x-y;
            break;
        case '*':
            result=x*y;
            break;
        case '/':
            if(y==0)
            {
                cerr<<"div zero error"<<endl;
                result=-1;
            }
            else
            {
                result=x/y;
            }
            break;
        case '%':
            if(y==0)
            {
                cerr<<"mod zero error"<<endl;
                result=-1;

            }
            else
            {
                result=x%y;
            }
        default:
            break;
    }
    return result;
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71

接下来，我们来写整体的代码。

1.3完整代码

我们要创建三个文件：BlockQueue.hpp Task.hpp Main.cc各文件内容如下所示：

BlockQueue.hpp

#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>
class BlockQueue
{
public:
    BlockQueue(const int &maxcap=gmaxcap):_maxcap(maxcap)
    {
        pthread_mutex_init(&_mutex,nullptr);
        pthread_cond_init(&_pcond,nullptr);
        pthread_cond_init(&_ccond,nullptr);

    }
    void push(const T&in)//输入型参数，const &
    {
        pthread_mutex_lock(&_mutex);
        while(is_full())
        {
            pthread_cond_wait(&_pcond,&_mutex);

        }
        _q.push(in);

        pthread_cond_signal(&_ccond);
        pthread_mutex_unlock(&_mutex);
    }
    void pop(T*out)
    {
        pthread_mutex_lock(&_mutex);
        while(is_empty())
        {
            pthread_cond_wait(&_ccond,&_mutex);
        }
        *out=_q.front();
        _q.pop();
        pthread_cond_signal(&_pcond);
        pthread_mutex_unlock(&_mutex);
    }
    ~BlockQueue()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_ccond);
        pthread_cond_destroy(&_pcond);
    }
private:
    bool is_empty()
    {
        return _q.empty();
    }
    bool is_full()
    {
        return _q.size()==_maxcap;
    }
private:
    std::queue<T> _q;
    int _maxcap; //队列中元素的上线
    pthread_mutex_t _mutex;
    pthread_cond_t _pcond; //生产者对应的条件变量
    pthread_cond_t _ccond;
};

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67

Task.hpp

#pragma once
#include <iostream>
#include <string>
#include <cstdio>
#include<string>
#include <functional>
using namespace std;
class CalTask
{
    using func_t = function<int(int, int, char)>;

public:
    CalTask() {}
    CalTask(int x, int y, char op, func_t func) 
        :_x(x),_y(y),_op(op),_callback(func)
    {}
    string  operator()()
    {
        int result=_callback(_x,_y,_op);
        char buffer[1024];
        snprintf(buffer,sizeof buffer,"%d %c %d=%d",_x,_op,_y,result);
        return buffer;
    }
    string toTaskstring()
    {
        char buffer[1024];
        snprintf(buffer,sizeof buffer,"%d %c %d=?",_x,_op,_y);
        return buffer;
    }   
private:
    int _x;
    int _y;
    char _op;
    func_t _callback;
};
const char*oper="+-*/%";
int mymath(int x,int y,char op)
{
    int result=0;
    switch(op)
    {
        case '+':
            result=x+y;
            break;
        case '-':
            result=x-y;
            break;
        case '*':
            result=x*y;
            break;
        case '/':
            if(y==0)
            {
                cerr<<"div zero error"<<endl;
                result=-1;
            }
            else
            
           		result=x/y;
            }
            break;
        case '%':
            if(y==0)
            {
                cerr<<"mod zero error"<<endl;
                result=-1;
            }
            else
            {
                result=x%y;
            }
        default:
            break;
    }
    return result;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76

Main.cc

include "BlockQueue.hpp"
#include "Task.hpp"
#include<sys/types.h>
#include<unistd.h>
#include<ctime>
#include<iostream>
using namespace std;


void *productor(void *bqs_)
{
    BlockQueue<CalTask> *bqs=static_cast<BlockQueue<CalTask>*>(bqs_);
    while(true)
    {
        int x=rand()%10+1;
        int y=rand()%5+1;
        int opercode=rand()%(sizeof(oper));
        CalTask T(x,y,oper[opercode],mymath);
        bqs->push(T);
        cout<<"生产任务: ";
        cout<<T.toTaskstring()<<endl;
        sleep(1);
    }
}
void *consumer(void *bqs_)
{
    BlockQueue<CalTask>*bqs=static_cast<BlockQueue<CalTask>*>(bqs_);
    while(true)
    {
        CalTask T;
        bqs->pop(&T);
        cout<<"消费任务: ";
        cout<<T()<<endl;

    }
}
int main()
{
    BlockQueue<CalTask> bqs;
    pthread_t p[5];
    pthread_t c[5];
    for(int i=0;i<5;i++)
    {
        pthread_create(&p[i],nullptr,productor,&bqs);
        pthread_create(&c[i],nullptr,consumer,&bqs);
    }
    for(int i=0;i<5;i++)
    {
        pthread_join(p[i],nullptr);
        pthread_join(c[i],nullptr);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

在代码中，有几个点需要注意一下：
第一点：
在这里插入图片描述
pthread_cond_wait的第二个参数一定是我们正在使用的互斥锁，这个函数在被运行时，会以原子性的方式将锁释放，然后将自己挂起，等待被条件变量唤醒。该函数在被唤醒时，会自动重新获取持有的锁，然后继续向下执行。
假如数个生产者线程一起被唤醒，然后先后持有锁，接着继续生产任务，当队列剩余的空间小于这些生产者生产的任务时，就会出现问题，所以让所有被唤醒的线程先通过while循环，如果有剩余的空间，再进行任务的生产活动。

生产线程这样处理，消费线程也要这样处理

大家可以在自己试这敲一下，有问题可以在评论区和我交流。
接下来，我们来查找一下这些代码有哪些"不足的地方"

2.代码中的“不足”

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

3.信号量

3.1什么是信号量

信号量的本质是一把计数器，一把衡量临界资源多少的计数器。只要拥有信号量，就在未来一定能够拥有临界资源的一部分。

申请信号量的本质：就是对临界资源的预定机制。

比如：我想去看电影，首先我要买票。我一旦买到票，无论我去不去看电影，都会有一个位置属于我。买票的过程==申请信号信号量的过程。
所以，在访问临界资源之前，我们可以申请信号量。通过申请信号量，我们就可以获知临界资源的使用情况。①只要申请成功，就一定有我可以访问的资源。②只要申请失败，说明条件不就绪，只能等待。如此，就不需要进入临界资源再进行检测了。

3.2信号量的相关接口

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

  • 信号量-1：申请资源，其过程必须是原子性的。简称P操作。
  • 信号量+1：归还资源，其过程必须是原子性的。简称V操作。
    所以，信号量的核心操作：PV原语。
    接下来，我们就使用信号量来完成我们的基于环形队列的生产消费模型。

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

3.3.1对环形队列的简单介绍

相信大家在C++学习期间到都模拟实现过环形队列队列。如图：
在这里插入图片描述
环形队列的逻辑结构为环形，但其存储结构实际上就是队列，其实就是一个数组，只不过用下标不断的%上队列的长度。
大家在模拟实现环形队列时，大家必定遇到的问题是：当rear==front时，究竟是环形队列已满还是环形队列为空呢？其实，这个问题有多种处理方式，今天就不讲了。
今天，我们的基于环形队列的生产消费模型必须遵守哪些规则呢？
我们来讲一个故事：
张三和李四在一个房间里做游戏，这个房间里有一张大圆桌，桌子上有很多的盘子。规定张三往每个盘子里放一个桃子

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/喵喵爱编程/article/detail/807314
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。