Linux——信号量和环形队列

位图 (10)

文章目录

Linux——信号量和环形队列
- - 概念
  - 信号量的PV原语
  - 线程申请信号量失败将会被挂起
- 信号量函数
- - sem_init初始化信号量
  - sem_destroy销毁信号量
  - sem_wait等待信号量
  - sem_post发布信号量
- 基于环形队列的生产者消费者模型
- - 代码实现

概念

临界资源：多线程执行流共享的资源就叫做临界资源

我们知道线程在操作临界资源时必须要进入临界区前先加锁，保证线程串行访问临界资源，避免出现多个线程同时访问临界资源而造成线程安全问题。而对临界区加锁，本质上是一个线程占用了整个临界资源，而实际上我们可以让整个临界资源分成不同的区域，让多个线程并发地访问不同区域，这样就能让多个线程同时访问临界资源而不会发生线程安全问题。这时候就需要引入信号量的概念

信号量本质是一个计数器，属于无符号整数，可以用来衡量临界资源临界资源的多少

执行流进入临界区前先申请信号量，对临界资源操作后，释放信号量。当线程申请到信号量时，意味着该线程在未来一定能够拥有临界资源的一部分，即申请信号量本质是对临界资源的某个区域进行了预定

信号量的PV原语

线程申请到信号量导致计数器sem–，该行为称为P原语。线程释放信号量导致计数器sem++，该行为称为V原语。
而每个线程都能够申请到信号量，意味着信号量本身作为公共资源，为了避免线程安全问题，信号量的PV原语必然具有原子性，也就是说信号量本身也作为临界资源。

P操作：将申请信号量的行为称为P操作，申请信号量的本质是申请临界资源中某个区域的使用权限，当申请成功时，该临界资源中的资源数目就会减一，本质上是计数器sem减一
V操作：将释放信号量的行为称为V操作，释放信号量的本质是归还临界资源某个区域的使用权限，当释放成功时，该临界资源的资源数目就会加一，本质上是计数器sem加一

线程申请信号量失败将会被挂起

当线程在申请信号量，若此时信号量sem为0，意味着申请的临界资源部分已经被全部被申请了，那么此时线程就在该信号量的队列中阻塞等待，直到信号量sem大于0时该线程才被释放。

意味着信号量的本质是计数器，但信号量还包括一个资源等待队列

信号量函数

sem_init初始化信号量

需要注意的是：

使用信号量需要链接pthread原生库
信号量函数调用成功返回0，失败返回-1，错误信息存储在错误码

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
Link with -pthread.

参数sem是信号量，需要传信号量的地址
pshared为0表示线程间共享，非零表示进程间共享
value为信号量初始值，即计数器sem的初始值

sem_destroy销毁信号量

#include <semaphore.h>
int sem_destroy(sem_t *sem);
Link with -pthread.

参数sem是信号量，需要传信号量的地址

sem_wait等待信号量

 #include <semaphore.h>
int sem_wait(sem_t *sem);

参数sem是信号量，需要传信号量的地址
作用：等待信号量，若传入的信号量不为0，那么等待成功并将信号量sem减一，并且继续往下执行。若传入的信号量为0，那么调用函数的线程就阻塞在信号量等待队列，直到有线程释放了该信号量

sem_post发布信号量

#include <semaphore.h>
int sem_post(sem_t *sem);

参数sem是信号量，需要传信号量的地址
作用：发布信号量，表示资源使用完毕，可以归还资源了。将信号量值加一

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

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

对于生产者而言，看到的环形队列是空间资源，队列中有空余的空间才能往里push数据。那么可以将队列中的剩余空间定义成一个计数器即信号量_ spacesem，生产者通过获取_spacesem来对获取对队列操作权限
对于消费者而言，看到的环形队列是数据资源，队列中有数据才能从中取到数据。那么可以将队列中的数据定义成一个计数器即信号量_ datasem，消费者通过获取_datasem来获取对队列的操作权限
一开始队列里全是空余的位置，因此_ spacesem初始值为队列的空间数目，_datasem初始值为0
大部分时候生产者和消费者都是并发执行的，除了以下两种情况：

刚开始队列为空时，有可能在同一个位置，生产者往队列push数据，而消费者从队列中pop数据。但是生产者的信号量初始值为队列的容量，则P操作生效；而消费者的信号量初始值为0，则P操作失败。因此一开始只有生产者往队列中push数据。即生产者和消费者具有互斥关系
当队列为满时，此时生产者和消费者都指向同一个位置。但此时队列的空余位置为0，那么生产者对应的信号量就为0从而P操作失败，进而阻塞等待；而队列中存在数据，消费者对应的信号量不为0那么消费者对应的P操作成功。因此队列为满时只有消费者从队列中pop数据。即此时生产者和消费者具有互斥关系

此外环形队列还有以下原则：

生产者和消费者不能同时对同一个位置进行访问，否则会造成数据不一致问题

消费者消费的位置不能超过生产者

生产者生产的位置不能超过消费者

代码实现

为了方便理解，以下以单生产者单消费者模型为例，生产者不停生产数据并往环形队列中存放，消费者不断的从队列中取数据进行消费

main.cc

void* productor(void* args)
{
   annulusqueue<int>* aq=static_cast<annulusqueue<int>*>(args);
    while(true)
    {
 int num=rand()%100;
aq->push(num);
cout<<"productor produce num: "<<num<<endl;
sleep(1);
    }
return nullptr;
}

void* consumer(void* args)
{
    annulusqueue<int>* caq=static_cast<annulusqueue<int>*>(args);
    while(true)
    {
        int ret;
        caq->pop(&ret);
        cout<<"consumer get num: "<<ret<<endl;
       // sleep(1);
    }
    return nullptr;
}

int main()
{
srand((unsigned int)time(nullptr)^getpid());//随机数种子
annulusqueue<int>* aq=new annulusqueue<int>();
    pthread_t p,c;//线程
    pthread_create(&p,nullptr,productor,aq);
    pthread_create(&c,nullptr,consumer,aq);
    

pthread_join(p,nullptr);
pthread_join(c,nullptr);

delete aq;
    return 0;
}

annulusqueue.hpp


#pragma once
#include<iostream>
#include<semaphore.h>
#include<vector>
#include<assert.h>
using namespace std;

static const int gmaxcp=5;
template<class T>
class annulusqueue
{
public:
annulusqueue(const int maxcp=gmaxcp):_maxcp(maxcp),_queue(maxcp)
{
    int n=sem_init(&_spacesem,0,_maxcp);//生产者以空间为信号量，那么初始空间即为队列容量
    assert(n==0);
    (void)n;
    int m=sem_init(&_datasem,0,0);//消费者以数据为信号量，那么初始的数据为0
    assert(m==0);
    (void)m;
_psetp=_cstep=0;//初始时，生产者和消费者都指向队列的开头即下标为0的位置

}
void P(sem_t &sem)
{
    int n=sem_wait(&sem);//若sem大于0则sem--并且往下走，若不满足条件则阻塞等待
    assert(n==0);//
    (void)n;
}
void V(sem_t &sem)
{
    int n=sem_post(&sem);//资源使用完成归还资源，sem++
    assert(n==0);
    (void)n;
}
void push(const T&in)
{
P(_spacesem);//对空间资源进行P操作即_spacesem--
_queue[_psetp++]=in;
_psetp%=_maxcp;
V(_datasem);//对数据资源进行V操作即_datasem++
}

void pop(T* out)
{
    P(_datasem);
    *out= _queue[_cstep++];
    _cstep%=_maxcp;
    V(_spacesem);
}

~annulusqueue()
{
    sem_destroy(&_spacesem);//销毁信号量
    sem_destroy(&_datasem);//销毁信号量
}

private:
sem_t _spacesem;//生产者对应的信号量--空间资源
sem_t _datasem;//消费者对应的信号量--数据资源
int _maxcp;//环形队列的容量
vector<T> _queue;//环形队列-实际上是数组
int _psetp;//生产者下标
int _cstep;//消费者下标
};

当不设置环形队列的大小时，我们默认将环形队列的容量上限设置为5
代码中的annulusqueue是用vector实现的，生产者每次生产的数据放到vector下标为 _ psetp的位置，消费者每次消费的数据来源于vector下标为_cstep的位置
生产者每次生产数据后_ psetp都会进行++，标记下一次生产数据的存放位置，++后的下标会与环形队列的容量进行取模运算，实现“环形”的效果。
消费者每次消费数据后_cstep都会进行++，标记下一次消费数据的来源位置，++后的下标会与环形队列的容量进行取模运算，实现“环形”的效果。
生产者生产随机数，往队列中放数据，并且打印日志。消费者从队列中拿数据，并且打印日志。
对于生产者而言，先要对空间资源进行P操作，即对队列中能使用的空间数目进行减一，_ spacesem–；对数据资源进行V操作，即队列中的数据量_datasem++加一

void push(const T&in)
{
P(_spacesem);//对空间资源进行P操作即_spacesem--
_queue[_psetp++]=in;
_psetp%=_maxcp;
V(_datasem);//对数据资源进行V操作即_datasem++
}

对于消费者而言，先对数据资源进行P操作，即当前位置的数据被消费了，意味着队列中的数据消失了一份，_datasem --；对空间资源进行V操作，当前位置的数据被消费，意味着当前位置空余下来供生产者存放数据，即队列中的空间资源加一， _spacesem++

void pop(T* out)
{
    P(_datasem);//对数据资源进行P操作即_datasem--
    *out= _queue[_cstep++];
    _cstep%=_maxcp;
    V(_spacesem);//对空间资源进行V操作即_spacesem++
}