Linux信号量

Posted 小赵小赵福星高照~

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Linux信号量相关的知识,希望对你有一定的参考价值。

POSIX信号量

文章目录


POSIX信号量和SystemV信号量作用相同,都是用于同步操作,达到无冲突的访问共享资源目的。 但POSIX可以用于线程间同步。那么信号量是什么?

先举个现实生活中的例子:看电影时我们要买票,我们买完票觉得那个座位就属于我们的,现实生活中,有很多场景是有"预定"机制,通过预定可以保证一人一座,电影院的售票系统卖出去的票不能超过电影院的承受能力

信号量(信号灯),本质是一个计数器,描述临界资源中有效个数的计数器,保护临界资源的安全性

比如count = 5;获取到一个临界资源count–,释放时count++;这里的count–是P();操作,count++是V();操作,信号量本身也是临界资源,因为要被每个线程看到,所以PV操作是原子的

伪代码:

struct sem

    int count;
    mutex lock;
    wait_queue *head;

P()

    lock();
    if(count > 0)
        count--;
    else
        wait;
    unlock();

那么信号量怎么用呢?

信号量相关接口

初始化信号量

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

参数:
pshared: 0表示线程间共享,非零表示进程间共享
value:信号量初始值

销毁信号量

int sem_destroy(sem_t *sem);

释放信号量自己占用的一切资源,满足条件成功返回0,否则返回-1且置errno为EBUSY

等待信号量

功能:等待信号量,会将信号量的值减1

int sem_wait(sem_t *sem); //P()

操作成功返回0,失败则返回-1且置errno

发布信号量

功能:发布信号量,表示资源使用完毕,可以归还资源了。将信号量值加1。

int sem_post(sem_t *sem);//V()

操作成功返回0,失败则返回-1且置errno

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

环形结构可以由数组来模拟,采用数组模拟,用模运算来模拟环状特性

环形结构起始状态和结束状态都是一样的,不好判断为空或者为满,所以可以通过加计数器或者标记位来判断满或者空。另外也可以预留一个空的位置,作为满的状态

但是我们现在有信号量这个计数器,就很简单的进行多线程间的同步过程。

consumer关心的是数据数量,productor关心的是空格子的数量

怎么保证数据不被覆盖或者不读取废弃数据:

快的人不能把慢的人套一个圈,慢的人不能超过快的人

大部分情况下,生产者和消费者不会访问同一个位置,什么情况下,会访问同一个位置?

快的人把慢的人套一个圈时,以及慢的人刚到快的人这里

数据:sem_data(数据信号量)

格子:sem_blank(格子信号量)

对于消费者:申请资源:P(sem_data)–,释放资源:V(sem_blank)++

对于生产者:申请资源:P(sem_blank)–,释放资源:V(sem_data)++

下面我们来完成基于环形队列的生产消费模型代码的编写:

Makefile的编写:

main:main.cc
	g++ $^ -o $@ -std=c++11 -lpthread
.PHONY:clean
clean:
	rm -f main

RingQueue.hpp

#pragma once
#include<semaphore.h>
#include<vector>
#include<iostream>
#define NUM 10
class RingQueue

private:
    std::vector<int> v;//数组模拟环形队列
    int _cap;
    sem_t sem_blank;//生产者
    sem_t sem_data;//消费者
    
    int c_index;
    int p_index;
private:
    void P(sem_t &s)
    
        sem_wait(&s);
    
    void V(sem_t &s)
    
        sem_post(&s);
    
public:
    RingQueue(int cap = NUM):_cap(cap),v(cap)
    
        sem_init(&sem_blank,0,_cap);
        sem_init(&sem_data,0,0);
        c_index = 0;
        p_index = 0;
    
    void Get(int& out)
    
        P(sem_data);//没有时会等待
        //消费
        out = v[c_index];
        c_index++;
        c_index %= _cap;//p_index等于数组的容量时回到0下标
        V(sem_blank);
    
    void Put(const int &in)
    
        P(sem_blank);
        //生产
        v[p_index] = in;
        p_index++;
        p_index %= _cap;//p_index等于数组的容量时回到0下标
        V(sem_data);
    
    ~RingQueue()
    
        sem_destory(&sem_blank);
        sem_destory(&sem_data);
        c_index = 0;
        p_index = 0;
     
;

main.cc

#include"RingQueue.hpp"
void* comsumer(void *ring_queue)

    RingQueue *rq = (RingQueue*)ring_queue;
    while(true)
    
        int data = 0;
        rq->Get(data);
        std::cout<<"comsumer done ...#" << data<<std::endl;
    

void* productor(void *ring_queue)

    RingQueue *rq = (RingQueue*)ring_queue;
    int count = 100;
	while(true)
    
        rq->Put(count);
        count++;
        if(count > 110)
        
            count = 100;
        
        std::cout<<"productor done: ..."<<std::endl;
    

int main()

    
    pthread_t c,p;
    RingQueue *rq = new RingQueue();
    pthread_create(&c,nullptr,comsumer,rq);
    pthread_create(&c,nullptr,productor,rq);
    
    pthread_join(c,nullptr);
    pthread_join(p,nullptr);
    
    delete rq;
    return 0;

以上是关于Linux信号量的主要内容,如果未能解决你的问题,请参考以下文章

Linux内核自旋锁

linux信号量之进程间同步

017_linux驱动之_信号量

Linux-驱动驱动策略----信号量

linux线程-使用信号量同步

linux进程间通信--信号量