第11章 进程间通信（4）_进程信号量

最新推荐文章于 2024-09-24 17:05:06 发布
最新推荐文章于 2024-09-24 17:05:06 发布
阅读量153 收藏
点赞数
分类专栏： Linux应用程序

3.4 进程信号量

（1）进程信号量简介

　　①本质上就是共享资源的数目，用来控制对共享资源的访问。

　　②用于进程间的互斥和同步。

　　③每种共享资源对应一个信号量，为了便于大量共享资源的操作引入信号量集，可对所有信号量一次性操作。对信号量集中所有操作可以要求全部成功，也可以部分成功。

　　④二元（也叫双态）信号量（信号灯）值为0或1。

　　⑤对信号量做PV操作（P减，V加）

（2）信号量集属性

（3）创建信号量集

头文件

#include <sys/sem.h>

函数

int semget(key_t key, int nsems, int flag);

参数

key： 用户指定的信号量集键值

size：信号量集中信号量的个数

flag：IPC_CREAT、IPC_EXCL等权限组合

功能

创建信号量集

返回值

成功返回内核中信号量集的标识ID，出错返回-1

（4）信号量集的控制

头文件

#include <sys/sem.h>

函数

int semctl(int semid, int semnum, int cmd, …/*union semun arg*/);

参数

（1）semid： 信号量集ID

（2）semnum：0表示对所有信号量操作，信号量编号从0开始。

（3）union semun{

　　　　int val; //放置获取或设置信号量集中某个信号量的值。

　　　　struct semid_ds* buf;//信号量集属性指针

　　　　unsigned short* array; //放置获取或设置信号量集中所有信号量的值。

      };

（4）cmd参数：通过参数设定对信号量集要执行的操作

　　①IPC_STAT：获取信号量集的属性       ==> buf

　　②IPC_SET： 设置信号量集的属性        ==> buf

　　③IPC_RMID：删除信号量集                ==> buf

　　④GETVAL：  返回信号量的值               ==> val

　　⑤SETVAL：  设置semnum信号量的值 ==> val

　　⑥GETALL：  获取所有信号量的值         ==> array

　　⑦SETALL：  设置所有信号量的初始值   ==> array

功能

控制信号量集

返回值

除GETALL以外所有GET命令，semctl函数都返回相应的值。其他命令的返回值为0.成功返回内核中信号量集的标识ID，出错返回-1

（5）信号量集的操作

头文件

#include <sys/sem.h>

函数

int semop(int semid, struct sembuf* sops, size_t nsops);

参数

（1）semid： 信号量集ID

（2）sops：sembuf结构体数组指针

（3）nsops：第2个参数中结构体数组的长度

（4）struct sembuf{

　　unsigned short sem_num; //信号量集中的信号量的编号

　　short sem_op; //正数为V操作，负数为P操作，0可用于测试资源是否用完。

　　short sem_flg;//SEM_UNDO标志，表示在进程结束时，相应的操作将被取消。如果设置了该标志，那么在进程没有释放共享资源就退出时，内核将代为释放。

};

功能

信号量集的操作

返回值

成功返回0，出错返回-1

备注

（1）用于信号量集中信号量的加和减操作（PV操作，注意P为减操作，V为加操作）

（2）可用于进程间的互斥和同步。

【编程实验】进程信号量实现ATM的互斥

（1）利用进程信号量的PV操作实现多进程对银行账户操作的互斥。

（2）I(1)：在银行账户上绑定信号量/信号灯(初始值为1)

（3）任何进程在取款时进行P(1)操作，然后withdraw()，取完后V(1)操作。

//pv.h

复制代码

#ifndef __PV_H__
#define __PV_H__

//初始化semnums个信号灯/信号量的值(value)
extern int I(int semnums, int value);

//对信号集(semid)中的信号灯(semindex)作P(value)操作
extern void P(int semid, int semindex,int value);

//对信号量集(semid)中的信号灯(semindex)作V(value)操作
extern void V(int semid, int semindex, int value);

//销毁信号量集(semid)
extern void D(int semid);

#endif

复制代码

//pv.c

复制代码

#include "pv.h"
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <assert.h>

//编译命令：gcc -o bin/pv.o -Iinclude -c src/pv.c 

/*封装对信号集的PV操作*/

//定义信号量集的Union
union semun{
    int                val;
    struct semid_ds    *buf;
    unsigned short     *array;
};

//创建信号量集，并初始化semnums个信号灯/信号量的值为value
int I(int semnums, int value)
{
    //创建信号量集
    int   semid = semget(IPC_PRIVATE, semnums, IPC_CREAT | IPC_EXCL | 0777);
    if(semid < 0){
        return -1; //错误时
    }

    union semun un;
    unsigned short* array = (unsigned short*)calloc(semnums, sizeof(unsigned short));
    
    int i = 0;
    for(; i< semnums; i++){
        array[i] = value;
    }

    un.array = array;
    //初始化信号量集中的所有的信号灯的初值
    //0:表示要初始化所有的信号灯
    if(semctl(semid, 0, SETALL, un) < 0){
        perror("semctl error");
        return -1;
    }

    free(array);

    return semid; //返回信号量集ID
}

//对信号集(semid)中的信号灯(semindex)作P(value)操作
void P(int semid, int semindex, int value)
{
    assert(value >= 0);
    
    /*
     * 定义sembuf类型的结构体数组，放置若个结构体变量
     * 对应要操作的信号量、要作的P或V操作
     */
    struct sembuf ops[] = {{semindex, -value, SEM_UNDO}};//只有1个元素，表示只操作
                                                         //一个信号量.-value表示P操作
    
    if(semop(semid, ops, sizeof(ops)/sizeof(ops[0])) < 0){
        perror("P semop error");
    }
}

//对信号量集(semid)中的信号灯(semindex)作V(value)操作
void V(int semid, int semindex, int value)
{
    assert( value >= 0);
    
    /*
     * 定义sembuf类型的结构体数组，放置若个结构体变量
     * 对应要操作的信号量、要作的P或V操作
     */
    struct sembuf ops[] = {{semindex, value, SEM_UNDO}};//只有1个元素，表示只操作
                                                         //一个信号量。+value表示V操作
    if(semop(semid, ops, sizeof(ops)/sizeof(ops[0])) < 0){
        perror("semop error");
    }
}

//销毁信号量集(semid)
void D(int semid)
{
    if(semctl(semid, 0, IPC_RMID, NULL) < 0){
        perror("semctl error");
    }
}

复制代码

//account.h

复制代码

#ifndef __ACCOUNT_H__
#define __ACCOUNT_H__

typedef struct
{
    int      code;    //帐号
    double   balance; //余额
    int      semid;   //在共享资源上绑定一个信号量集
}Account;

//取款
extern double withdraw(Account* a, double amt); //amt == amount
//存款
extern double deposit(Account* a, double amt);
//查看帐户余额
extern double get_balance(Account* a);

#endif  //__ACCOUNT_H__

复制代码

//account.c

复制代码

#include "account.h"
#include "pv.h"
#include <string.h>
#include <assert.h>

//取款
double withdraw(Account* a, double amt) //amt == amount
{
    assert(a != NULL);
    
    //对信号量集semid中的0号信号灯作P操作
    P(a->semid, 0, 1);   //P操作
    
    if(amt < 0 || amt > a->balance){
        V(a->semid, 0, 1);
        return 0.0;
    }

    double balance = a->balance; //先取余额
    sleep(1); //为模拟进程下可能出现的问题

    balance -= amt;
    a->balance = balance; //更新余额。在读取余额和更新余额之间有
                          //故意留出“时间窗口”。
    
    //对信号量集semid中的0号信号灯作V操作
    V(a->semid, 0, 1);  //V操作   
    
    return amt;    
}

//存款
double deposit(Account* a, double amt)
{
    assert(a != NULL);
    
    if(amt < 0){
        return 0.0;
    }
    
    P(a->semid, 0, 1); //P操作

    double balance = a->balance; //先取余额

    sleep(1); //为模拟多进程下可能出现的问题

    balance += amt;
    a->balance = balance; //更新余额。
    
    V(a->semid, 0, 1);  //V操作

    return amt;    
}

//查看帐户余额
double get_balance(Account* a)
{
    assert(a != NULL);
    
    P(a->semid, 0, 1); //P操作
    double balance = a->balance;
    V(a->semid, 0, 1); //V操作

    return balance;
}

复制代码

//account_test.c

复制代码

#include "account.h"
#include "pv.h"
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>

int main(void)
{
    //在共享内存中创建银行帐户
    int shmid;
    if((shmid = shmget(IPC_PRIVATE, sizeof(Account), IPC_CREAT | IPC_EXCL | 0777)) < 0){
        perror("shmget error");
        exit(1);
    }

    //进程共享内存映射（a为返回的映射地址）
    Account* a= (Account*)shmat(shmid, 0, 0);
    if(a == (Account*)-1){
        perror("shmat error");
        exit(1);
    }

    //银行帐户初始化
    a->code = 100001;
    a->balance = 10000;
    printf("balance: %f\n", a->balance);

    //创建信号量集并初始化
    a->semid = I(1, 1);//1个信号量，初始值为1
    if(a->semid < 0){
        perror("I(1, 1) init error");
        exit(1);
    }
    
    //父子进程都进行取款
    pid_t pid;
    if((pid = fork()) < 0){
        perror("fork error");
        exit(1);
    }else if(pid > 0){ //parent process
        //父进程进行取款操作
        double amt = withdraw(a, 10000);
        printf("pid %d withdraw %f from code %d\n", getpid(), amt, a->code);
       
        int semid = a->semid;

        //解除映射
        shmdt(a);

        wait(0);
        
        //删除共享内存区
        shmctl(shmid, IPC_RMID, NULL);
        
        //销毁信号量
        D(semid);
        
    }else{ //child process
        //子进程会继承父进程映射的共享内存地址
        //子进程进行取款操作
        double amt = withdraw(a, 10000);
        printf("pid %d withdraw %f from code %d\n", getpid(), amt, a->code);

        //解除映射
        shmdt(a);
    }

    return 0;
}
/*输出结果：
 [root@localhost 11.IPC]# gcc -o bin/account_test -Iinclude src/pv.c src/account.c src/account_test.c
 [root@localhost 11.IPC]# bin/account_test
 balance: 10000.000000
 pid 2229 withdraw 10000.000000 from code 100001
 pid 2230 withdraw 0.000000 from code 100001
 */

复制代码

【编程实验】进程信号量实现的读者/写者的同步

（1）目的：利用进程信号量的PV操作实现进程间的同步问题

（2）在共享内存中读写数据（读者和写者问题）

（3）设置两个信号量并初始化为0：控制读的信号量I(s1, 0)，控制写的信号量I(s2,1)

//read_writer.c

复制代码

#include <sys/shm.h>
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

//共享资源
typedef struct{
    int val;
    int semid; //一个资源绑定一定信号量集
}Storage;

//初始化信号量集
void init(Storage* s)
{
    assert(s != NULL);
    //创建信号量集(包含2个信号量)
    if((s->semid = semget(IPC_PRIVATE, 2, IPC_CREAT | IPC_EXCL | 0777)) < 0){
        perror("semget error");
        exit(1);
    }
    
    //对信号 量中的所有信号量初始化
    union semun{
        int              val;
        struct semid_ds  *ds;
        unsigned short   *array;
    };

    union semun un;
    //信号量的初始设置
    unsigned short array[2] = {0, 1}; //分别为控制读、写
    un.array = array;
    if(semctl(s->semid, 0, SETALL, un) < 0){
        perror("semctl error");
        exit(1);
    }
}

//销毁信号量集
void destroy(Storage* s)
{
    assert( s != NULL);

    if(semctl(s->semid, 0, IPC_RMID, NULL) < 0){
        perror("semctl error");
        exit(1);
    }
}

void write(Storage* s, int value)
{   
    struct sembuf ops_p = {1, -1, SEM_UNDO};
    struct sembuf ops_v = {0,  1, SEM_UNDO};

    //等待可写：P(s1)操作
    if(semop(s->semid, &ops_p, 1) < 0){
        perror("semop error");    
    }

    s->val = value; //写入数据
    printf("%d write %d\n", getpid(), value);

    //通知己可读：V(s0)
    if(semop(s->semid, &ops_v, 1) < 0){
        perror("semop error");
    }
}

void read(Storage* s)
{   
    struct sembuf ops_p = {0, -1, SEM_UNDO};
    struct sembuf ops_v = {1,  1, SEM_UNDO};

    //等待可读：P(s0)操作
    if(semop(s->semid, &ops_p, 1) < 0){
        perror("semop error");    
    }

    int value = s->val; //读取数据
    printf("%d read %d\n", getpid(), value);

    //通知己可写：V(s1)
    if(semop(s->semid, &ops_v, 1) < 0){
        perror("semop error");
    }
}

int main(void)
{
    //将共享资源Storage创建在共享内存中
    int shmid;
    if((shmid = shmget(IPC_PRIVATE, sizeof(Storage), IPC_CREAT | IPC_EXCL | 0777)) < 0){
        perror("shmget error");
        exit(1);
    }

    //共享内存映射

    Storage* s = (Storage*)shmat(shmid, 0, 0);
    if(s == (Storage*)-1){
        perror("shmat error");
        exit(1);
    }

    //创建信号量集并初始化
    init(s);

    pid_t pid = fork();

    if(pid < 0){
        perror("fork error");
        exit(1);
    }else if (pid > 0){ //parent process
        int i = 1;
        for(; i<=10; i++){
            write(s, i);
        }

        wait(0);
        destroy(s);//释放信号量集
        shmdt(s); //解除映射
        shmctl(shmid, IPC_RMID, NULL); //删除共享内存
    }else{ //child process
        int i = 1;
        for(; i<=10; i++){
            read(s);
        }

        shmdt(s);//解除共享内存映射
    }

    return 0;
}

/*输出结果
 [root@localhost 11.IPC]# bin/read_writer
 2376 write 1
 2377 read 1
 2376 write 2
 2377 read 2
 2376 write 3
 2377 read 3
 2376 write 4
 2377 read 4
 2376 write 5
 2377 read 5
 2376 write 6
 2377 read 6
 2376 write 7
 2377 read 7
 2376 write 8
 2377 read 8
 2376 write 9
 2377 read 9
 2376 write 10
 2377 read 10
 */

地址：https://www.cnblogs.com/5iedu/p/6593802.html

小坏坏_
关注
专栏目录
进程通信——信号量
makunIT的博客
03-22 1025
文章目录浅谈什么是信号量ftok（）函数获取IPC关键字信号量的相关函数信号量的使用代码示例 浅谈什么是信号量 在讲信号量之前，先了解两个概念同步和互斥：一条食品生产线上，假设A、B共同完成一个食品的包装任务，A负责将食品放到盒子里，B和C负责将盒子打包。必须得是A先装食品B再打包吧，要是B不按规则先打包，那A还装啥，所以就需要一种机制方法保证A先进行B再进行，“信号量”就是这种机制方法，AB之间...
Linux进程间通信——使用信号量
haierboos
08-24 4438
这篇文章将讲述别一种进程间通信的机制——信号量。注意请不要把它与之前所说的信号混淆起来，信号与信号量是不同的两种事物。有关信号的更多内容，可以阅读我的另一篇文章：Linux进程间通信——使用信号。下面就进入信号量的讲解。 一、什么是信号量 为了防止出现因多个程序同时访问一个共享资源而引发的一系列问题，我们需要一种方法，它可以通过生成并使用令牌来授权，在任一时刻只能有一个执行线程访问代码的临...
进程间通信——信号量
最新发布
sc020826的博客
09-24 652
该操作是在访问完共享资源(执行完临界区代码)后要做的一个操作，就是将该信号量的值+1。3. POSIX 无名信号量 -----> 内核中。2. POSIX 无名信号量 ----> 内存中。1. POSIX 有名信号量。
进程信号------信号量
flf1234567898的博客
12-06 350
信号量 信号量不是为了传输数据，而是为了进程控制 信号量的实现 ： 计数器 + PCB等待队列 PCB等待队列是放获取不到信号量的进程 互斥： 如何保证互斥？ 3.1：计数器的值只能为0或者1，当计数器的值为0的时候，表示资源不可以被访问，当计数器值为1的时候表示资源可以被访问 3.2：初始计数器值为1，表示可以访问资源 3.3：获取信号量 3.3.1 对信号量中的计数器进行预减操作（减1） 3.3.2 判断预减之后的值 小于0：不能信号量，被放到了PCB等待队列中进行等待4 等于0：可以获取到信号量，对信
进程通信之信号量
xngjing的博客
08-14 582
一 信号量（信号灯）概念： 信号量提供一种访问机制，让一个临界区同一时间只有一个进程在访问他，也就是说信号量用来协调进程对共享资源的访问的。 信号量是一个特殊的变量，程序对其访问都是原子操作，只允许对他进行等待（P）和发送信息（V）的操作。最简单的信号量只能取0和1的变量，这也是信号量最常见的一种形式，叫做二进制信号量。可以取多个正整数的信号量称为信号量。 信号量与其他进程间通信方式不大相同
进程管理——信号量
qq_43581718的博客
04-19 1317
一、概述 1、信号量方法 (1)、信号量可以初始为一个非负值 (2)、只能由P和V操作来访问信号量 2、P和V操作 (1)、P操作：测试、DOWN操作 (2)、V操作：增加、UP操作 二、整型信号量 P：Wait(s): { while s<0 do-op s:s-1; } V：Signal(s): { s:s+1; } 进程P利用信号量实现互斥的伪代码： do{ P(mutex) ...
进程间通信：信号量
weixin_43887148的博客
11-13 1759
进程间通信的机制，它们最初由AT&T System V.2版本的UNIX引IPC (Inter-Process Communication，进程间通信)机制，或被更常见的称为System V IPC。正如我们所看到的，它们并不是进程间通信的唯一方法，但人们通常把这些特定的机制称为System V IPC。 信号量 当我们编写的程序使用了线程时，不管它是运行在多用户系统上、多进程系统上，还是运行在多用户多进程系统上，我们通常会发现，程序中存在着一部分临界代码，我们需要确保只有一个进程(或一个执行线程）
第七章进程间通信1
08-04
本章主要关注管道通信和System V IPC，而完全网络兼容的进程间通信——Socket将在第十三章涉及。 **管道通信**是最简单的进程间通信形式之一。它通过一个共享文件（或称为pipe文件）连接读进程和写进程，允许数据以...
进程间通信 之 信号量
aa804738534的博客
04-23 378
共享内存允许两个或多个进程访问给定的同一块存储区域。已知当一个进程被启动时，系统会为其创建一个0~4G的虚拟内存空间，根据虚拟地址与物理地址之间的映射关系，进程可以通过操作虚拟地址，实现对物理页面的操作。一般情况下，每个进程的虚拟地址空间会与不同的物理地址进行映射，但是当使用共享内存进行通信时，系统会将同一段物理内存映射给不同的进程。两个进程的虚拟地址空间与共享内存之间的映射关系如图1所示。 图1 映射关系 系统中的物理内存和虚拟内存都通过页面来管理，为多个进程分配共享内存，实际是为进程分配一个或多
进程间通信之 信号量
aa804738534的博客
04-23 481
Linux系统采用多道程序设计技术，允许多个进程同时在内核中运行，但同一个系统中的多个进程之间，可能因为进程合作或资源共享，产生制约关系。制约关系分为直接相互制约关系和间接相互制约关系： （1）直接相互制约关系。利用管道机制实现进程间通信，当管道为空时，读进程由于无法从管道中读取数据而进入阻塞；当管道存满时，写进程由于无法向管道中写入数据而进入阻塞，类似于这种需要进程间协调合作导致的制约关系，称为直接相互制约关系。 （2）间接相互制约关系。若当前系统中只有1台打印机，当进程A占用打印机时，进程B也申请使
进程间的通信-信号量（C语言）
m0_57037805的博客
09-24 983
2022，讲述了Linux下的信号有哪些，进程间通信-->信号量的捕捉和发送，内带注释加实例
进程的信号量通信
weixin_65633498的博客
04-19 628
其中，semid是信号量集合的标识，semnum是要处理信号量集合中的信号量序号，cmd为要执行的操作命令，arg为控制操作需要的参数，是一个指向联合semun的指针。其中，semid是进程调用semget后返回的信号量集合的标识，sops是用户提供的信号量操作模版数组（sembuf）的指针，nsops为数组sembuf中的元素数（即一次需进行的操作数）。其中，key为用户进程指定的信号量集合的关键字，nsems为信号量集合中的信号量数，semflg为访问标志。/*集合中的信号量个数*/
4.进程信号量
qq_43808700的博客
04-18 716
linux中的信号 用户在Linux命令行输入命令,在Shell下启动一个前台进程。 用户按下Ctrl-C, 产生一个硬件中断，被OS获取，解释成信号，发送给目标前台进程 前台进程因为收到信号，进而引起进程退出 Ctrl-C特点 Ctrl-C 产生的信号只能发给前台进程。一个命令后面加个& 可以放到后台运行,这样Shell不必等待进程结束就可以接受新的命令,启动新的进程。 Shell可以同时运行一个前台进程和任意多个后台进程,只有前台进程才能接到像Ctrl-C 这种控制键产生的信号。 前台进.
linux 进程 信号量
lpaim的博客
03-28 252
linux 进程 信号量
进程——信号量机制
zy702432103的博客
11-19 457
信号量机制 1） 整型信号量 1.信号量定义为一个整型量； 2.根据初始情况赋相应的值； 3.仅能通过两个原子操作来访问。 2）记录型信号量 整型信号量符合“有限等待”原则 signal释放资源后，当CPU被分配给等待进程后，等待进程仍可继续执行，可以符合“有限等待”。 但整型信号量不符合“让权等待”原则 整型信号量的wait操作，当s ≤0时，当前进程会占着CPU不断测试； 信号量原语不能被打...
04进程间通信——信号量
qq_68915288的博客
05-23 544
如：进程A和进程B，都需要访问一个共享资源“互斥设备”，那么我们可以使用一个信号量来表示能不能访问这个资源，每一个进程需要访问共享资源前，先去访问该信号量，如果能访问共享资源 (信号量允许)，则先把信号量设置为"NO"，然后再去访问该共享资源，访问完共享资源，再把信号量设置为“YES”用于进程内部的线程间的通信，隶属于进程的地址空间，其他的进程不能访问，但是一个进程的所有线程共享一个进程的地址空间，所以一个进程的所有线程都可以访问。：一个进程或线程因请求资源而阻塞时，对已获得的资源保持不放。
进程间通信----信号量
m0_60529319的博客
03-27 1267
信号量，是一种特殊的变量：只能对信号量执行P操作和V操作P操作(要执行代码的时候): 如果信号量的值 == 0, 则挂起该进程，如果信号量的值 > 0, 则把该信号量减1V操作(执行完代码的时候): 如果有进程因该信号量而被挂起，则恢复该进程运行，如果没有进程因该信号量而挂起，则把该信号量加1注意：P操作、V操作都是原子操作，即其在执行时，不会被中断。注意：此指的“信号量”是指System V IPC的信号量，与线程所使用的信号量不同。该信号量，用于进程间通信。
Linux进程间通信详解：管道、信号与IPC系统调用
本PPT专注于第二十四讲Linux操作系统中的进程间通信（IPC）。该部分旨在帮助学习者深入理解Linux系统的进程通信机制，包括其目的与要求，重点难点以及多种通信方式。 首先，课程强调了理解Linux进程通信的重要性，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值