Linux的信号量

信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。

**

1、特点

**
1、信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。

2、信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。

3、每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。

4、支持信号量组。

例子：就像一个房间，信号量相当于开门的钥匙，房间相当于连接资源（一次仅允许一个进程使用的资源；如：A进程正在使用临界资源，B进程就无法使用，等A进程完成后才行。）
在Linux中有许多的信号量集，
P操作：拿锁；V操作：放回锁；
**

2、信号量的相关函数

**
最简单的信号量是只能取 0 和 1 的变量，这也是信号量最常见的一种形式，叫做二值信号量（Binary Semaphore）。而可以取多个正整数的信号量被称为通用信号量。

Linux 下的信号量函数都是在通用的信号量数组上进行操作，而不是在一个单一的二值信号量上进行操作。

1 #include <sys/sem.h>
2 // 创建或获取一个信号量组：若成功返回信号量集ID，失败返回-1
3 int semget(key_t key, int num_sems, int sem_flags);
4 // 对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1
5 int semop(int semid, struct sembuf semoparray[], size_t numops);  
6 // 控制信号量的相关信息
7 int semctl(int semid, int sem_num, int cmd, ...);

semget创建新的信号量集合时，必须指定集合中信号量的个数（即num_sems），通常为1； 如果是引用一个现有的集合，则将num_sems指定为 0 。
所需头文件:
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
函数返回值：成功：返回信号量集的标识符；出错：-1，错误原因存于error中
key：0(IPC_PRIVATE)：会建立新信号量集对象，key大于0的32位整数：视参数semflg来确定操作，通常要求此值来源于ftok返回的IPC键值
nsems：创建信号量集中信号量的个数，该参数只在创建信号量集时有效

msgflg：
0：取信号量集标识符，若不存在则函数会报错
IPC_CREAT：当semflg&IPC_CREAT为真时，如果内核中不存在键值与key相等的信号量集，则新建一个信号量集；如果存在这样的信号量集，返回此信号量集的标识符
IPC_CREAT|IPC_EXCL：如果内核中不存在键值与key相等的信号量集，则新建一个消息队列；如果存在这样的信号量集则报错

在semop函数中，sembuf结构的定义如下：

1 struct sembuf 
2 {
3     short sem_num; // 信号量组中对应的序号，0～sem_nums-1
4     short sem_op;  // 信号量值在一次操作中的改变量，取值为-1为P操作，取值为+1表示V操作
5     short sem_flg; // IPC_NOWAIT, SEM_UNDO
6 }

sem_op 是一次操作中的信号量的改变量：
若sem_op > 0，表示进程释放相应的资源数，将 sem_op 的值加到信号量的值上。如果有进程正在休眠等待此信号量，则换行它们。
若sem_op < 0，请求 sem_op 的绝对值的资源。
如果相应的资源数可以满足请求，则将该信号量的值减去sem_op的绝对值，函数成功返回。

当相应的资源数不能满足请求时，这个操作与sem_flg有关。
sem_flg 指定IPC_NOWAIT，则semop函数出错返回EAGAIN。
sem_flg 没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：
1、当相应的资源数可以满足请求，此信号量的semncnt值减1，该信号量的值减去sem_op的绝对值。成功返回；
2、此信号量被删除，函数smeop出错返回EIDRM；
3、进程捕捉到信号，并从信号处理函数返回，此情况下将此信号量的semncnt值减1，函数semop出错返回EINTR

若sem_op == 0，进程阻塞直到信号量的相应值为0：
当信号量已经为0，函数立即返回。
如果信号量的值不为0，则依据sem_flg决定函数动作：
sem_flg指定IPC_NOWAIT，则出错返回EAGAIN。
sem_flg没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：
1、信号量值为0，将信号量的semzcnt的值减1，函数semop成功返回；
2、此信号量被删除，函数smeop出错返回EIDRM；
3、进程捕捉到信号，并从信号处理函数返回，在此情况将此信号量的semncnt值减1，函数semop出错返回EINTR

成功：返回信号量集的标识符；出错：-1，错误原因存于error中。

在semctl函数中的命令有多种，这里就说两个常用的：

1、SETVAL：用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。
2、IPC_RMID：删除一个信号量集合。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。

信号量（父子之间通信）：

#include "stdio.h"
#include <sys/sem.h>
#include <sys/ipc.h>
#include <sys/types.h>
// int semget(key_t key, int num_sems, int sem_flags);
// // 对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1
// int semop(int semid, struct sembuf semoparray[], size_t numops);  
// // 控制信号量的相关信息
// int semctl(int semid, int sem_num, int cmd, ...);

union semun{
    int                  val;//**
    struct semid_ds     *buf;
    unsigned short      *array;
    struct seminfo      *_buf;
    };


void pGetKey(int id)
{
	struct sembuf set;
	set.sem_num=0;
	set.sem_op=-1;
	set.sem_flg=SEM_UNDO;
	semop(id,&set,1);
	printf("getKey\n");
}

void vPutBackKey(int id){
	struct sembuf set;
        set.sem_num=0;
        set.sem_op=1;
        set.sem_flg=SEM_UNDO;
        semop(id,&set,1);
        printf("put back the key\n");

}


int main()
{
    key_t key;
    int semid;
    key =ftok(".",2);
    semid=semget(key,1,IPC_CREAT|0600);//1:表示信号量集合中有一个信号量；
                                        //获取/创建信号量

    union semun initsem;
    initsem.val=0;


    semctl(semid,0,SETVAL,initsem);//0：操作弟0个信号量；初始化信号量；setval设置信号量的值，设置为initsem

    int pid=fork();
    if (pid>0){
        //去拿锁
	pGetKey(semid);
        printf("this is father\n" );
	vPutBackKey(semid);
        //
	semctl(semid,0,IPC_RMID);
    }
    else if(pid==0){
       // printf("this is child\n");
	//pGetKey(semid);
	 printf("this is child\n");
	vPutBackKey(semid);
    }else{
        printf("fork error\n");
    }


}

共享内存与信号量：

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<sys/sem.h>
  4 
  5 // 联合体，用于semctl初始化
  6 union semun
  7 {
  8     int              val; /*for SETVAL*/
  9     struct semid_ds *buf;
 10     unsigned short  *array;
 11 };
 12 
 13 // 初始化信号量
 14 int init_sem(int sem_id, int value)
 15 {
 16     union semun tmp;
 17     tmp.val = value;
 18     if(semctl(sem_id, 0, SETVAL, tmp) == -1)
 19     {
 20         perror("Init Semaphore Error");
 21         return -1;
 22     }
 23     return 0;
 24 }
 25 
 26 // P操作:
 27 //    若信号量值为1，获取资源并将信号量值-1 
 28 //    若信号量值为0，进程挂起等待
 29 int sem_p(int sem_id)
 30 {
 31     struct sembuf sbuf;
 32     sbuf.sem_num = 0; /*序号*/
 33     sbuf.sem_op = -1; /*P操作*/
 34     sbuf.sem_flg = SEM_UNDO;
 35 
 36     if(semop(sem_id, &sbuf, 1) == -1)
 37     {
 38         perror("P operation Error");
 39         return -1;
 40     }
 41     return 0;
 42 }
 43 
 44 // V操作：
 45 //    释放资源并将信号量值+1
 46 //    如果有进程正在挂起等待，则唤醒它们
 47 int sem_v(int sem_id)
 48 {
 49     struct sembuf sbuf;
 50     sbuf.sem_num = 0; /*序号*/
 51     sbuf.sem_op = 1;  /*V操作*/
 52     sbuf.sem_flg = SEM_UNDO;
 53 
 54     if(semop(sem_id, &sbuf, 1) == -1)
 55     {
 56         perror("V operation Error");
 57         return -1;
 58     }
 59     return 0;
 60 }
 61 
 62 // 删除信号量集
 63 int del_sem(int sem_id)
 64 {
 65     union semun tmp;
 66     if(semctl(sem_id, 0, IPC_RMID, tmp) == -1)
 67     {
 68         perror("Delete Semaphore Error");
 69         return -1;
 70     }
 71     return 0;
 72 }
 73 
 74 
 75 int main()
 76 {
 77     int sem_id;  // 信号量集ID
 78     key_t key;  
 79     pid_t pid;
 80 
 81     // 获取key值
 82     if((key = ftok(".", 'z')) < 0)
 83     {
 84         perror("ftok error");
 85         exit(1);
 86     }
 87 
 88     // 创建信号量集，其中只有一个信号量
 89     if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
 90     {
 91         perror("semget error");
 92         exit(1);
 93     }
 94 
 95     // 初始化：初值设为0资源被占用
 96     init_sem(sem_id, 0);
 97 
 98     if((pid = fork()) == -1)
 99         perror("Fork Error");
100     else if(pid == 0) /*子进程*/ 
101     {
102         sleep(2);
103         printf("Process child: pid=%d\n", getpid());
104         sem_v(sem_id);  /*释放资源*/
105     }
106     else  /*父进程*/
107     {
108         sem_p(sem_id);   /*等待资源*/
109         printf("Process father: pid=%d\n", getpid());
110         sem_v(sem_id);   /*释放资源*/
111         del_sem(sem_id); /*删除信号量集*/
112     }
113     return 0;
114 }