Linux进程间通信之信号量

╰半橙微兮° 2022-07-12 07:36 284阅读 0赞

## 信号量 ##

信号量，我们可以理解为一种计数器，记录的是可共享资源的数量。信号量主要被用于协调多个进程对同一共享资源的占用访问。  
如果一个进程想要获得并使用共享资源，需经历以下过程：

1.  测试查看控制该共享资源的信号量。
2.  若该信号量的值大于0，则进程可以使用该资源。资源分配给该进程以后，信号量的值减1。表示该资源分配出去到了一个单位。
3.  若该信号量的值等于0，则该进程将被挂起，进入休眠等待状态。直到资源被释放，信号量的值大于0，该进程返回步骤1。（进程被挂起：把控制进程的数据结构PCB链接到信号量集的等待队列中）
4.  当一个共享资源被释放时，控制该资源的信号量将加1。

上述的共享资源我们通常称为临界资源，进程中访问临界资源的代码称为临界区。  
现在我们可知，信号量是为了保护临界资源而被设立的（防止多个进程抢占同一临界资源），而信号量本身也算是一种临界资源。信号量又由谁来保护呢？为了解决这一问题，信号量的加1减1操作，均被设计成原子操作来保护自身。（原子操作：要么不做，要么做完做成功）

## 存在形式 ##

信号量同我们人类一样，是“群居动物”。它并非是单一的存在。而必须定义为一个含有一个或多个信号量的集合，信号量集。当我们创建这个信号量集的时候，需要指定信号量的个数。  
信号量集有一个最大缺陷就是，信号量集的创建（semget）与信号量值得初始化（semctl）是相互独立开的。不是原子操作。这样很危险。例如，当我们创建好了一个信号量集，在我们还没有对它进行初始化时，该信号量集就被分配使用，造成无法预料的后果。  
同其他PC一样，当占用共享资源的所有进程都执行结束，信号量并不会被程序主动释放掉，所以这种程序总是存在潜在的危险性。

## 信号量的维护 ##

操作系统内核为每个信号量集合都维护着一个semid\_ds结构：

struct semid_ds {
    struct ipc_perm sem_perm; /* 信号量集的操作许可权限 */
    struct sem *sem_base; /* 某个信号量sem结构数组的指针，当前信号量集中的每个信号量对应其中一个数组元素 */
    ushort sem_nsems; /* sem_base 数组的个数 */
    time_t sem_otime; /* 最后一次成功修改信号量数组的时间 */
    time_t sem_ctime; /* 成功创建时间 */
    };

每个信号量又有一个无名结构表示：

struct sem {
    ushort semval; /* 信号量的当前值 */
    short sempid; /* 最后一次返回该信号量的进程ID 号 */
    ushort semncnt; /* 等待semval大于当前值的进程个数 */
    ushort semzcnt; /* 等待semval变成0的进程个数 */
    };

## 信号量的操作函数 ##

### semget 获取信号量 ###

定义为：

int semget(key_t key,int nsems,int semflg)

参数：

1.  key，为key\_t类型的值。System V IPC使用此类型作为系统对它们的唯一标识（名字）。实就为int类型。通常使用ftok函数类获取key值。ftok把一个已经存在的路径名和一个整数标识转换成一个key\_t值。  
    定义:  
    `key_t ftok(const char* pathment,int proj_id);`
2.  nsems为信号量的个数。
3.  semflg为创建的方式。选项有IPC\_CREAT和IPC\_EXCL。有以下两种使用方式：  
    ~ IPC\_CREAT和IPC\_EXCL一起使用。表示创建一个信号量集，若所需的信号量集已存在，则报错退出。  
    ~ IPC\_CREAT单独使用。表示创建一个信号量集，若所需的信号量集已存在，则直接获取。

### semop,对信号量进行加减操作 ###

定义为：

int semop(int semid,struct sembuf *sops,unsigned nsops)

参数：

1.  semid，指要操作的信号量的id。（即semget的返回值）
2.  sops为一个指针，指向一个由sembuf结构表示的信号量操作数组。（为什么是数组？因为有时我们需要对信号量进行批量操作）  
    sembuf的结构为：

struct sembuf{
      unsigned short sem_num;//表示信号量的“下标”，用来标识信号量集合中的某一信号量
      short sem_op;/*当sem_op为正值时，表示进程释放占用的资源数；当sem_op为0时，表示进程希望等待该信号量的值变成0；当semop为负值时，表示进程需要占用的资源数。*/
      short sem_flg;//有IPC_NOWAIT,SEM_UNDO,0。
    }

注意上述备注sem\_flg的SEM\_UNDO标识，其用于将修改的信号量的值在进程正常退出（调用exit退出或main执行完）或异常退出（如段异常，除0异常，收到KILL信号等）时归还信号量。  
例如：假设现在有两个信号量A，B。两个的信号量值都为10。现认为A设置了SEM\_UNDO标志，而B没有设置。  
![这里写图片描述][SouthEast]

假设A，B量信号量所控制的临界资源分别向c，d两个进程分配了2个单位资源。A，B的值此时都变为8。  
![这里写图片描述][SouthEast 1]

c，d进程异常结束，按道理说，c，d所占用的临界资源释放，那么A，B两个信号量的值应该都再加上2，返回10。其实不然，我们会发现，设置了SEM\_UNDO的信号量A的值返回了10，而没有设置SEM\_UNDO的信号量B的值仍为8 。  
![这里写图片描述][SouthEast 2]

### semctl ###

既然有信号量的创建申请，那必然就有信号量的销毁。semctl正有此功能。  
定义：

int semctl(int semid, int semnum,int cmd,...)

参数：

1.  semid，同上；
2.  semnum，信号量的编号，也可理解为此信号量在所属信号量集中的下标；
3.  cmd，此命令共有10种，常用的有IPC\_RMID,SETVAL两种  
    当cmd为IPC\_RMID时，smctl执行的是删除销毁功能。此时可变参数无用。只需考虑前三个参数即可。当cmd为SELVAL时，semctl执行的是初始化的功能，初始化的是信号量的值。此时可变参数类型为semun，它是多个命令特定参数的联合。

union semun{
    int val;//信号量的初值
    struct semid_ds *buf;
    unsigned sgort *array;
    }

在调用semctl进行信号量值初始化前，需要先将第四个参数，联合semun内的val进行初始化。

## 示例：一个简单的信号量操作 ##

### 头文件 ###

#ifndef __COMM__
    #define __COMM__
    
    #include<stdio.h>
    #include<sys/types.h>
    #include<sys/ipc.h>
    #include<sys/sem.h>
    #include<stdlib.h>
    
    #define PATHNAME "."
    #define PROJID 0x6666 //0 ~ 258
    #define SIZE 4096*1
    
    union semun {
             int              val;    /* Value for SETVAL */
             struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
             unsigned short  *array;  /* Array for GETALL, SETALL */
             struct seminfo  *__buf;  /* Buffer for IPC_INFO(Linux-specific) */
             };
    
    
    int initSem(int semid,int which);
    int commSem(int nums,int flags);
    int creatSem(int nums);
    int gerSem(int nums);
    int P(int semid,int which);
    int V(int semid,int which);
    int destorySem(int semid);
    #endif // __COMM__

### 信号量的创建申请 ###

int commSem(int nums,int flags)
    {
        key_t _k=ftok(PATHNAME,PROJID);
        if(_k < 0)
        {
        perror("ftok");
            return -1;
        }
        int semid = semget(_k,nums,flags);
        if(semid < 0)
        {
            perror("semget");
            return -2;
        }
        return semid;
    }
    int creatSem(int nums)
    {
        return commSem(nums,IPC_CREAT | IPC_EXCL | 0666);
    }
    int gerSem(int nums)
    {
        return commSem(nums,IPC_CREAT);
    }

### 信号量的初始化 ###

int initSem(int semid,int which)
    {
        union semun sem;
        sem.val = 1;
        if(semctl(semid,which,SETVAL,sem) < 0)
        {
            perror("initSem_semctl");
            return -1;
        }
        return 0;
    }

### 信号量的删除 ###

int destorySem(int semid)
    {
        if(semctl(semid,0,IPC_RMID) < 0)
        {
            perror("semctl Destory");
            return -1;
        }
        return 0;
    }

### 信号量的P/V操作 ###

int op_sem(int semid,int op,int which)
    {
        struct sembuf s;
        s.sem_num = which;
        s.sem_op = op;
        s.sem_flg = SEM_UNDO;
    
        return semop(semid,&s,1);
    }
    
    int P(int semid,int which)
    {
        if(op_sem(semid,-1,which) < 0)
        {
            perror("P_op_sem");
            return -1;
        }
        return 0;
    }
    int V(int semid, int which)
    {
        if(op_sem(semid,1,which) < 0)
        {
            perror("V_op_sem");
            return -1;
        }
        return 0;
    }

### 测试用例 ###

#include"comm.h"
    
    
    int main()
    {
        printf("test_sem\n");
        int semid = creatSem(1);
        if(semid < 0)
        {
            return -1;
        }
        int ret = initSem(semid,0);
        if(ret < 0)
        {
            return -2;
        }
        P(semid,0);
        sleep(15);
        printf("nihao \n");
        exit(1);
        printf("DEBUG:exit\n");
        V(semid,0);
        sleep(5);
    
        destorySem(semid);
    
        return 0;
    }
    
    /*
    int main()
    {
        printf("test_sem\n");
        int semid = creatSem(1);
        if(semid < 0)
        {
            return -1;
        }
        int ret = initSem(semid,0);
        if(ret < 0)
        {
            return -2;
        }
        pid_t id = fork();
        if(id==0)
        {
            //child
         //     printf("child proc,pid:%d,ppid:%d\n",getpid(),getppid());
            while(1)
            {
                P(semid,0);
                usleep(13300);
                printf("A");
                fflush(stdout);
                usleep(10000);
                printf("A");
                fflush(stdout);
                V(semid,0);
            }
        }
        else
        {
            //father
        //  printf("father proc,pid:%d,ppid:%d\n",getpid(),getppid());
            while(1)
            {
            P(semid,0);
            usleep(1123);
            printf("B");
            fflush(stdout);
            usleep(100);
            printf("B");
            fflush(stdout);
            V(semid,0);
            }
        }
    //  sleep(10);
        destorySem(semid);
        return 0;
    }*/

[SouthEast]: /images/20220711/e8175218bf484c049cffed6eb39072bb.png
[SouthEast 1]: /images/20220711/8ee3e1c9723f4a038df7eac81d643e9c.png
[SouthEast 2]: /images/20220711/5c6643b3c3db4fba8fad0046695cbba1.png