Linux——信号量、环形队列

Linux——信号量和环形队列

概念

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

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

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

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

信号量的PV原语

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

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

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

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

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

信号量函数

sem_init初始化信号量

需要注意的是：

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

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

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

• pshared为0表示线程间共享，非零表示进程间共享

• value为信号量初始值，即计数器sem的初始值

sem_destroy销毁信号量

#include 
int sem_destroy(sem_t *sem);
Link with -pthread.

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

sem_wait等待信号量

 #include 
int sem_wait(sem_t *sem);

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

sem_post发布信号量

#include 
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数据。即此时生产者和消费者具有互斥关系

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

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

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

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

代码实现

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

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
#include
#include
#include
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++
}

• 生产者生产的慢，消费者消费的快。生产者每隔一秒生产一次，消费者不断的消费。结果是生产者生产一个数据消费者就消费一个数据

• 生产者生产的快，消费者消费的慢。生产者不停的生产，消费者每隔一秒消费一次。结果是生产者生产了队列空余位置数目的数据，然后消费者消费一个，生产者生产一个。并且消费者生产是按照生产时间从先往后消费