温馨提示×

温馨提示×

您好,登录后才能下订单哦!

密码登录×
登录注册×
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》

POSIX信号量——环形buf实现生产者消费者模型

发布时间:2020-06-27 22:33:06 来源:网络 阅读:853 作者:程红玲OOO 栏目:编程语言

system v和posix版本信号量的接口函数

POSIX信号量——环形buf实现生产者消费者模型


本篇介绍POSIX版本的Semaphore(信号量)


Mutex变量是非0即1的,可看作一种资源的可用数量,初始化时Mutex是1,表示有一个可用资源,加锁时获得该资源,将Mutex减到0,表示不再有可用资源,解锁时释放该资源,将Mutex重新加到1,表示又有了一个可用资源。


信号量(Semaphore)和Mutex类似,表示可用资源的数量,和Mutex不同的是这个数量可以大于1。如果信号量描述的资源数目是1时,此时的信号量和互斥锁相同!


POSIX semaphore库函数,这种信号量不仅可用于同一进程的线程间同步,也可用于不同进程间的同步。


有了互斥量和条件变量还提供信号量的原因 是:信号量的主要目的是提供一种进程间同步的方式。这种同步的进程可以共享也可以不共享内存区。虽然信号量的意图在于进程间的同步,互斥量和条件变量的意图在于线程间同步,但信号量也可用于线程间同步,互斥量和条件变量也可通过共享内存区进行进程间同步。 但应该根据具体应用考虑到效率和易用性进行具体的选择。



POSIX版本信号量分为有名信号量无名信号量

POSIX信号量——环形buf实现生产者消费者模型

有名信号量函数:

sem_open 用于创建或打开一个信号量,信号量是通过 name 参数即信号量的名字来进行标识的。

sem_close 用于关闭打开的信号量。当一个进程终止时,内核对其上仍然打开的所有有名信号量自动执行这个操作。

 POSIX 有名信号量是随内核持续的。

sem_unlink 用于将有名信号量立刻从系统中删除,但信号量的销毁是在所有进程都关闭信号量的时候。

无名信号量有关函数:


POSIX信号量——环形buf实现生产者消费者模型

POSIX信号量——环形buf实现生产者消费者模型


以下代码是用无名信号量实现的生产者消费者模型


生产者消费者模型:

代码说明:

1.push()和pop()的数据(datatype)本篇用的是基本类型,如果是自定义类型的话,需要实现赋值运算符的重载

2.数组实际上是线性的,内存中并没有环形数组,我们定义了一个固定大小的数组,当数组的最后一个元素也被填上数据时,检查数组的第一个元素(下标为0的元素)是否已经被消费者读过,如果已经读过,那么生产者就可以继续放数据,当数组满时(即数组中的元素一个也没有被消费者读),生产者会等待。

3.sem_init()初始化两个信号量sem_p(控制生产者)和sem_c(控制消费者),pshared为0时,表示信号量用于同一进程的线程间同步

 sem_destroy()使两个信号量回到初始化前的状态

 sem_wait() 可以获得资源,相当于P操作,把给定信号量减一

 sem_post() 可以释放资源,相当于V操作,进行加一操作

 当信号量的值为0时,sem_wait()会将进程挂起等待,sem_trywait()不会将进程挂起

4.多生产者和多消费者模型则需要加锁,其实加用两把不同的锁实现效率更高,可以使线程并发执行,而我在下面代码中指使用了一把锁,在下面代码中我把它标记了出来


代码实现:

ring.cpp

#include <iostream>
#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
using namespace std;

#define SEM_PRO 20
#define SEM_CON 0
#define SIZE SEM_PRO

typedef int datatype; 

datatype ring[SIZE];//数组的定义
datatype pro,con;

sem_t sem_p;//product
sem_t sem_c;//consumer


void init_ring(datatype (*ring)[SIZE])
{
    pro=0;
    con=0;
 }

datatype& push(datatype &data,int index)
{
    ring[pro++]=data;
    datatype tmp=ring[pro-1];
    pro%=SIZE;
    return tmp;
}

datatype& pop(int index)
{
    con++;
    datatype tmp=ring[con-1];
    con%=SIZE;
    return tmp;
}

void* product(void* arg)
{
    while(1){
        datatype data=rand()%50;
        sem_wait(&sem_p);
        datatype val=push(data,pro);
        cout<<"product done...,val is:"<<val<<endl;
        sem_post(&sem_c);
        sleep(1);
    }
}

void* consumer(void* arg)
{
    while(1){
        sem_wait(&sem_c);
        datatype val=pop(con);
        cout<<"consumer done...,val is:"<<val<<endl;
        sem_post(&sem_p);
        sleep(8);
    }
}

int main()
{
    init_ring(&ring);

    sem_init(&sem_p,0,SEM_PRO);
    sem_init(&sem_c,0,0);

    pthread_t tid1,tid2;
    pthread_create(&tid1,NULL,product,NULL);
    pthread_create(&tid2,NULL,consumer,NULL);

    sem_destroy(&sem_p);
    sem_destroy(&sem_c);

    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);

    return 0;
}

Makefile

ring:ring.cpp
    g++ -o $@ $^ -lpthread

.PHONY:clean
clean:
    rm -f ring


下面两次运行生产者和消费者的速度有所变化,导致运行结果不同

第一次运行结果:

POSIX信号量——环形buf实现生产者消费者模型

第二次运行结果:

POSIX信号量——环形buf实现生产者消费者模型


生产者消费者模型:

#include <iostream>
#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
using namespace std;

#define SEM_PRO 20
#define SEM_CON 0
#define SIZE SEM_PRO

typedef int datatype;

datatype ring[SIZE];
datatype pro,con;

sem_t sem_p;//product
sem_t sem_c;//consumer

void init_ring(datatype (*ring)[SIZE])
{
    pro=0;
    con=0;
}

datatype& push(datatype &data,int index)
{
    ring[pro++]=data;
    datatype tmp=ring[pro-1];
    pro%=SIZE;
    return tmp;
}

datatype& pop(int index)
{
    con++;
    datatype tmp=ring[con-1];
    con%=SIZE;
    return tmp;
}

void* product(void* arg)
{
     while(1){
        int value;
        datatype data=rand()%50;
        sem_wait(&sem_p);//申请资源,进行减一操作
        pthread_mutex_lock(&lock);
        datatype val=push(data,pro);//往buf里push数据
        sem_getvalue(&sem_p,&value);//得到此时信号量sem_p的值,即还有几个空格可>以使用
        pthread_mutex_unlock(&lock);
        cout<<"product"<<(int)arg<<" done...,val is:"<<val<<endl;
        cout<<"sem_p is:"<<value<<",";
        pthread_mutex_lock(&lock);//**********************************应加不同的锁
        sem_post(&sem_c);//释放资源
        sem_getvalue(&sem_c,&value);//得到此时信号量sem_c的值,即有多少数据可以>取
        pthread_mutex_unlock(&lock);
        cout<<"sem_c is:"<<value<<endl;

        sleep(5);
    }
}

void* consumer(void* arg)
{
     while(1){
        int value;
        sem_wait(&sem_c);
        pthread_mutex_lock(&lock);
        datatype val=pop(con);
        sem_getvalue(&sem_c,&value);
        pthread_mutex_unlock(&lock);
        cout<<"consumer"<<(int)arg<<" done...,val is:"<<val<<endl;
        cout<<"sem_c is:"<<value<<",";
        pthread_mutex_lock(&lock);//**********************************应加不同的锁
        sem_post(&sem_p);
        sem_getvalue(&sem_p,&value);
        pthread_mutex_unlock(&lock);
        cout<<"sem_p is:"<<value<<endl;
        sleep(1);
    }
}

int main()
{
    init_ring(&ring);

    sem_init(&sem_p,0,SEM_PRO);
    sem_init(&sem_c,0,0);

    pthread_t tid1,tid2,tid3;
    pthread_create(&tid1,NULL,product,(void*)1);
    pthread_create(&tid2,NULL,product,(void*)2);
    pthread_create(&tid3,NULL,product,(void*)3);

    pthread_t tid4,tid5;
    pthread_create(&tid4,NULL,consumer,(void*)4);
    pthread_create(&tid5,NULL,consumer,(void*)5);

    sem_destroy(&sem_p);
    sem_destroy(&sem_c);

    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);
    pthread_join(tid4,NULL);
    pthread_join(tid5,NULL);

    return 0;
}

运行结果:

POSIX信号量——环形buf实现生产者消费者模型


很多时候信号量和互斥量,条件变量三者都可以再某种应用中使用,那这三者的差异有哪些呢,下面列出了这三者之间的差异 :

  • 互斥量必须由给它上锁的线程解锁。而信号量不需要由等待它的线程进行挂出,可以在其他进程进行挂出操作。

  • 互斥量要么被锁住,要么是解开状态,只有这两种状态。而信号量的值可以支持多个进程成功进行 wait 操作。

  • 信号量的挂出操作总是被记住,因为信号量有一个计数值,挂出操作总会将该计数值加 1 ,然而当向条件变量发送一个信号时,如果没有线程等待在条件变量,那么该信号会丢失。



向AI问一下细节

免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

AI