Linux系统编程——进程同步与互斥：System V 信号量

信号量概述

信号量广泛用于进程或线程间的同步和互斥，信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。

编程时可根据操作信号量值的结果判断是否对公共资源具有访问的权限，当信号量值大于 0 时，则可以访问，否则将阻塞。PV 原语是对信号量的操作，一次 P 操作使信号量减１，一次 V 操作使信号量加１。

在实际应用中两个进程间通信可能会使用多个信号量，因此 System V 的信号量以集合的概念来管理，具体操作和 Posix 信号量大同小异，详情请点此链接：http://blog.csdn.net/tennysonsky/article/details/46496201。

信号量集合数据结构：struct semid_ds，此数据结构中定义了整个信号量集的基本属性。

[cpp] view plain copy

1. /* Obsolete, used only for backwards compatibility and libc5 compiles */  
2. struct semid_ds  
3. {  
4.     struct ipc_perm sem_perm;       /* permissions .. see ipc.h */  
5.     __kernel_time_t sem_otime;      /* last semop time */  
6.     __kernel_time_t sem_ctime;      /* last change time */  
7.     struct sem  *sem_base;      /* ptr to first semaphore in array */  
8.     struct sem_queue *sem_pending;      /* pending operations to be processed */  
9.     struct sem_queue **sem_pending_last;    /* last pending operation */  
10.     struct sem_undo *undo;          /* undo requests on this array */  
11.     unsigned short  sem_nsems;      /* no. of semaphores in array */  
12. };  

信号量数据结构：struct sem，此数据结构中定义了信号量的基本属性。

[cpp] view plain copy

1. /* One semaphore structure for each semaphore in the system. */  
2. struct sem  
3. {  
4.     int semval;     /* current value *信号量的值*/  
5.     int sempid;     /* pid of last operation *最后一个操作信号量的进程号*/  
6.     struct list_head sem_pending; /* pending single-sop operations */  
7. };  

System V 信号量基本操作

使用 shell 命令操作信号量：

查看信号量：ipcs -s

删除信号量：ipcrm -s semid

以下函数所需头文件如下：

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

1）创建信号量集合

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

功能：

创建或打开一个信号量集合，该集合中可以包含多个信号量。

参数：

key：进程间通信键值，通过调用 ftok() 函数得到的键值，详情请点此链接：http://blog.csdn.net/tennysonsky/article/details/46331643。

nsems：创建的信号量的个数。如果只是访问而不创建则可以指定该参数为 0，一旦创建了该信号量，就不能更改其信号量个数，只要不删除该信号量，重新调用该函数创建该键值的信号量，该函数只是返回以前创建的值，不会重新创建。

semflg：标识函数的行为及信号量的权限，其取值如下：

IPC_CREAT：创建信号量。
IPC_EXCL：检测信号量是否存在。
位或权限位：信号量位或权限位后可以设置信号量的访问权限，格式和 open 函数的 mode_ t 一样（open() 的使用请点此链接），但可执行权限未使用。

返回值：

成功：信号量集标识符

失败：返回 -1

2）控制信号量集合、信号量

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

功能：

对信号量集合以及集合中的信号量进行操作。

参数：

semid：信号量集标识符。

semnum：集合中信号量的序号，指定对哪个信号量操作， 只对几个特殊的 cmd 操作有意义。

cmd：信号量控制类型。semctl() 函数可能有3个参数，也可能有4个参数，参数的个数由 cmd 决定。当有4个参数时，第4个参数为联合体：

[cpp] view plain copy

1. union semun{  
2.     int         val;    /*信号量的值*/  
3.     struct semid_ds *buf;   /*信号量集合信息*/  
4.     unsigned short  *array;/*信号量值的数组*/  
5.     struct seminfo  *__buf;/*信号量限制信息*/  
6. };  

cmd 的取值如下：

GETVAL：获取信号量的值。此时函数有3个参数。semctl() 函数的返回值即为信号量的值。

SETVAL：设置信号量的值。此时函数有4个参数。第4个参数为联合体中的val，其值为信号量的值。 

IPC_STAT：获取信号量集合的信息。此时函数有4个参数。第4个参数为联合体中的__buf。

IPC_SET：设置信号量集合的信息。此时函数有4个参数。第4个参数为联合体中的__buf。

IPC_RMID：删除信号量集。此时函数有3个参数,第2个参数semnum不起作用。

GETALL：获取所有信号量的值。此时函数有4个参数，第2个参数semnum不起作用。第4个参数为联合体中的array，其值为用来存放所有信号量值的数组的首地址。

SETALL：设置所有信号量的值 。参数说明同上。

IPC_INFO：获取信号量集合的限制信息。此时函数有4个参数，第2个参数semnum不起作用。第4个参数为联合体中的__buf。

GETPID：获取信号的进程号，即最后操作信号量的进程。此时函数有3个参数。semctl() 函数的返回值即为信号的进程号。

GETNCNT：获取等待信号的值递增的进程数。此时函数有3个参数。semctl() 函数的返回值即为进程数。

GETZCNT：获取等待信号的值递减的进程数。此时函数有3个参数。semctl() 函数的返回值即为进程数。

返回值：

成功：0

失败：-1

3）操作信号量

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

功能：

操作信号量，主要进行信号量加减操作。

参数：

semid：信号量集标识符。
sops：操作信号量的结构体（struct sembuf）数组的首地址( 结构体定义在 sys/sem.h )，此结构体中的数据表明了对信号量进行的操作。

[cpp] view plain copy

1. struct sembuf{  
2.     unsigned short  sem_num;    /*信号量的序号*/  
3.     short       sem_op;     /*信号量的操作值*/  
4.     short       sem_flg;    /*信号量的操作标识*/  
5. };  

结构体成员使用说明如下：

sem_num：信号量集中信号量的序号

sem_op 取值如下：

sem_op > 0：信号量的值在原来的基础上加上此值。

sem_op < 0：如果信号量的值小于 semop 的绝对值，则挂起操作进程。如果信号量的值大于等于 semop 的绝对值，则信号量的值在原来的基础上减去 semop 的绝对值。

sem_op = 0：对信号量的值进行是否为 0 测试。若为 0 则函数立即返回，若不为 0 则阻塞调用进程。

sem_flag 取值如下： 

IPC_NOWAIT：在对信号量的操作不能执行的情况下使函数立即返回。

SEM_UNDO：当进程退出后，该进程对信号量进行的操作将被撤销。

nsops：操作信号量的结构体数组中元素的个数。

返回值：

成功：0

失败：-1

使用示例

示例一：

[cpp] view plain copy

1. #include <sys/types.h>  
2. #include <sys/sem.h>  
3. #include <sys/ipc.h>  
4. #include <stdlib.h>  
5. #include <stdio.h>  
6.   
7. int main(int argc, char *argv[])  
8. {  
9.     key_t key;  
10.   
11.     //创建key值  
12.     key = ftok(".", 'a');  
13.     if(key == -1)  
14.     {  
15.         perror("ftok");  
16.     }  
17.       
18.     //查看信号量  
19.     system("ipcs -s");  
20.       
21.     int semid;  
22.       
23.     //1: 创建的信号量的个数  
24.     semid = semget(key, 1, IPC_CREAT|0666); //创建信号量  
25.     if(semid == -1)  
26.     {  
27.         perror("semget");  
28.     }  
29.       
30.     system("ipcs -s"); //查看信号量  
31.       
32.     //删去信号量  
33.     // 0: 代表对第0个信号量进行操作  
34.     // IPC_RMID：删除信号量集  
35.     semctl(semid, 0, IPC_RMID);  
36.       
37.     system("ipcs -s"); //查看信号量  
38.       
39.     return 0;  
40. }  

运行结果如下：

示例二：

[cpp] view plain copy

1. #include <sys/types.h>  
2. #include <sys/ipc.h>  
3. #include <sys/sem.h>  
4. #include <stdlib.h>  
5. #include <stdio.h>  
6.   
7. /*解决编译出错的问题*/  
8. #define IPC_INFO 3  
9.   
10. int main(int argc, char *argv[])  
11. {  
12.     key_t key;  
13.   
14.     //创建key值  
15.     key = ftok(".", 'a');  
16.     if(key == -1)  
17.     {  
18.         perror("ftok");  
19.     }  
20.       
21.     system("ipcs -s"); //查看信号量  
22.       
23.     int semid;  
24.     //1: 创建的信号量的个数  
25.     semid = semget(key, 1, IPC_CREAT|0666);//创建信号量  
26.     if(semid == -1)  
27.     {  
28.         perror("semget");  
29.     }  
30.       
31.     system("ipcs -s"); //查看信号量  
32.       
33.     struct seminfo buf;  
34.     /* 
35.     //struct seminfo相关成员 
36.     struct seminfo { 
37.         int semmap; 
38.         int semmni; 
39.         int semmns; 
40.         int semmnu; 
41.         int semmsl; 
42.         int semopm; 
43.         int semume; 
44.         int semusz; 
45.         int semvmx; 
46.         int semaem; 
47.     }; 
48.      
49.     */  
50.       
51.     //IPC_INFO：获取信号量集合的限制信息。  
52.     //此时函数有4个参数，第2个参数semnum不起作用。  
53.     semctl(semid, 0, IPC_INFO, &buf);  
54.       
55.     printf("buf.semmni = %d\n", buf.semmni);  
56.     printf("buf.semmns = %d\n", buf.semmns);  
57.     printf("buf.semmnu = %d\n", buf.semmnu);  
58.     printf("buf.semmsl = %d\n", buf.semmsl);  
59.     printf("buf.semopm = %d\n", buf.semopm);  
60.     printf("buf.semume = %d\n", buf.semume);  
61.     printf("buf.semusz = %d\n", buf.semusz);  
62.     printf("buf.semvmx = %d\n", buf.semvmx);  
63.     printf("buf.semaem = %d\n", buf.semaem);  
64.   
65.     //删去信号量  
66.     // 0: 代表对第0个信号量进行操作  
67.     // IPC_RMID：删除信号量集  
68.     semctl(semid, 0, IPC_RMID);  
69.       
70.     system("ipcs -s"); //查看信号量  
71.       
72.     return 0;  
73. }  

运行结果如下：

示例三：

[cpp] view plain copy

1. #include <sys/types.h>  
2. #include <sys/sem.h>  
3. #include <sys/ipc.h>  
4. #include <stdlib.h>  
5. #include <stdio.h>  
6.   
7. int main(int argc, char *argv[])  
8. {  
9.     key_t key;  
10.   
11.     //创建key值  
12.     key = ftok(".", 'a');  
13.     if(key == -1)  
14.     {  
15.         perror("ftok");  
16.     }  
17.       
18.     //查看信号量  
19.     system("ipcs -s");  
20.       
21.     int semid;  
22.       
23.     //1: 创建的信号量的个数  
24.     semid = semget(key, 1, IPC_CREAT|0666); //创建信号量  
25.     if(semid == -1)  
26.     {  
27.         perror("semget");  
28.     }  
29.       
30.     system("ipcs -s"); //查看信号量  
31.       
32.     int ret;  
33.       
34.     /* 
35.     //SETVAL: 设置信号量的值。此时函数有4个参数。第4个参数为联合体中的val，其值为信号量的值。  
36.     union semun{ 
37.         int         val;        //信号量的值 
38.         struct semid_ds *buf;   //信号量集合信息 
39.         unsigned short  *array; //信号量值的数组 
40.         struct seminfo  *__buf; //信号量限制信息 
41.     }; 
42.     */  
43.     ret = semctl(semid, 0, SETVAL, 20);  
44.     if(ret == -1)  
45.     {  
46.         perror("semctl");  
47.     }  
48.       
49.     //GETVAL：获取信号量的值。函数返回值即为信号量的值。  
50.     ret = semctl(semid, 0, GETVAL);  
51.     if(ret == -1)  
52.     {  
53.         perror("semctl");  
54.     }  
55.     printf("ret = %d\n", ret);  
56.   
57.     // 0: 代表对第0个信号量进行操作  
58.     // IPC_RMID：删除信号量集  
59.     semctl(semid, 0, IPC_RMID);  
60.       
61.     system("ipcs -s");  
62.       
63.     return 0;  
64. }  

运行结果如下：

示例四：

[cpp] view plain copy

1. #include <sys/types.h>  
2. #include <sys/sem.h>  
3. #include <sys/ipc.h>  
4. #include <stdlib.h>  
5. #include <stdio.h>  
6. #include <string.h>  
7.   
8. int main(int argc, char *argv[])  
9. {  
10.     key_t key;  
11.   
12.     //创建key值  
13.     key = ftok(".", 'a');  
14.     if(key == -1)  
15.     {  
16.         perror("ftok");  
17.     }  
18.       
19.     //查看信号量  
20.     system("ipcs -s");  
21.       
22.     int semid;  
23.       
24.     //2: 创建的信号量的个数  
25.     semid = semget(key, 2, IPC_CREAT|0666); //创建信号量  
26.     if(semid == -1)  
27.     {  
28.         perror("semget");  
29.     }  
30.       
31.     system("ipcs -s"); //查看信号量  
32.       
33.     int ret;  
34.   
35.     unsigned short sem_arry[2] = {30,20};  
36.       
37.     /* 
38.     //SETALL: 设置所有信号量的值。此时函数有4个参数，第2个参数semnum不起作用。第4个参数为联合体中的array，其值为用来存放所有信号量值的数组的首地址。 
39.     union semun{ 
40.         int         val;        //信号量的值 
41.         struct semid_ds *buf;   //信号量集合信息 
42.         unsigned short  *array; //信号量值的数组 
43.         struct seminfo  *__buf; //信号量限制信息 
44.     }; 
45.     */  
46.     ret = semctl(semid, 0, SETALL, sem_arry);  
47.     if(ret == -1)  
48.     {  
49.         perror("semctl");  
50.     }  
51.       
52.       
53.     bzero(sem_arry, sizeof(sem_arry));  
54.     //GETALL：获取所有信号量的值。此时函数有4个参数，第2个参数semnum不起作用。第4个参数为联合体中的array，其值为用来存放所有信号量值的数组的首地址。  
55.     ret = semctl(semid, 0, GETALL, sem_arry);  
56.     if(ret == -1)  
57.     {  
58.         perror("semctl");  
59.     }  
60.     printf("sem_arry[0] = %d\n", sem_arry[0]);  
61.     printf("sem_arry[1] = %d\n", sem_arry[1]);  
62.   
63.     // IPC_RMID：删除信号量集  
64.     semctl(semid, 0, IPC_RMID);  
65.     system("ipcs -s");  
66.       
67.     return 0;  
68. }  

运行结果如下：

示例五：

[cpp] view plain copy

1. //此范例使用信号量来同步共享内存的操作  
2. #include <stdio.h>   
3. #include <sys/types.h>   
4. #include <sys/ipc.h>   
5. #include <sys/sem.h>   
6. #include <sys/shm.h>  
7. #include <unistd.h>  
8. #include <sys/wait.h>  
9.   
10. #define SHM_KEY 0x33   
11. #define SEM_KEY 0x44   
12.   
13. union semun   
14. {   
15.     int val;   
16.     struct semid_ds *buf;   
17.     unsigned short *array;   
18. };   
19.   
20. int P(int semid)   
21. {   
22.     struct sembuf sb;  
23.     /* 
24.     //操作信号量的结构体 
25.     struct sembuf{ 
26.         unsigned short  sem_num;//信号量的序号 
27.         short       sem_op;     //信号量的操作值 
28.         short       sem_flg;    //信号量的操作标识 
29.     };   
30.     */  
31.     sb.sem_num = 0;   
32.     sb.sem_op = -1;  
33.     //SEM_UNDO：当进程退出后，该进程对信号量进行的操作将被撤销。  
34.     sb.sem_flg = SEM_UNDO;   
35.   
36.     //操作1个信号量  
37.     if(semop(semid, &sb, 1) == -1){   
38.         perror("semop");   
39.         return -1;   
40.     }   
41.   
42.     return 0;   
43. }   
44.   
45. int V(int semid)   
46. {   
47.     struct sembuf sb;  
48.     /* 
49.     //操作信号量的结构体 
50.     struct sembuf{ 
51.         unsigned short  sem_num;//信号量的序号 
52.         short       sem_op;     //信号量的操作值 
53.         short       sem_flg;    //信号量的操作标识 
54.     };   
55.     */  
56.       
57.     sb.sem_num = 0;   
58.     sb.sem_op = 1;  
59.     //SEM_UNDO：当进程退出后，该进程对信号量进行的操作将被撤销。  
60.     sb.sem_flg = SEM_UNDO;   
61.   
62.     //操作1个信号量  
63.     if(semop(semid, &sb, 1) == -1){   
64.         perror("semop");   
65.         return -1;   
66.     }   
67.       
68.     return 0;   
69. }   
70.   
71. int main(int argc, char **argv)   
72. {  
73.     pid_t pid;   
74.     int i, shmid, semid;   
75.     int *ptr = NULL;   
76.     union semun semopts;   
77.     /* 
78.     union semun{ 
79.         int         val;        //信号量的值 
80.         struct semid_ds *buf;   //信号量集合信息 
81.         unsigned short  *array; //信号量值的数组 
82.         struct seminfo  *__buf; //信号量限制信息 
83.     }; 
84.     */  
85.   
86.     //创建一块共享内存, 存一个int变量  
87.     if ((shmid = shmget(SHM_KEY, sizeof(int), IPC_CREAT | 0600)) == -1) {   
88.         perror("msgget");   
89.         return -1;  
90.     }   
91.   
92.     //将共享内存映射到进程, fork后子进程可以继承映射  
93.     ptr = (int *)shmat(shmid, NULL, 0);  
94.     if (ptr == (int *)-1) {   
95.         perror("shmat");  
96.         return -1;  
97.     }  
98.       
99.     *ptr = 0; //赋值为0  
100.   
101.     // 创建一个信号量用来同步共享内存的操作   
102.     if ((semid = semget(SEM_KEY, 1, IPC_CREAT | 0600)) == -1) {   
103.         perror("semget");   
104.         return -1;  
105.     }   
106.   
107.     //初始化信号量    
108.     semopts.val = 1;   
109.     if (semctl(semid, 0, SETVAL, semopts) < 0) {   
110.         perror("semctl");   
111.         return -1;  
112.     }   
113.   
114.     if ((pid = fork()) < 0) { //创建进程  
115.         perror("fork");  
116.         _exit(0);  
117.     }else if (pid == 0){ // Child  
118.         // 子进程对共享内存加1   
119.         for (i = 0; i < 100000; i++) {   
120.             P(semid);   
121.             (*ptr)++;   
122.             V(semid);   
123.             printf("child: %d\n", *ptr);   
124.         }   
125.           
126.     } else { //Parent  
127.         // 父进程对共享内存减1   
128.         for (i = 0; i < 100000; i++) {   
129.             P(semid);   
130.             (*ptr)--;   
131.             V(semid);   
132.             printf("parent: %d\n", *ptr);   
133.         }   
134.           
135.         //如果子进程结束，回收其资源  
136.         wait(NULL);  
137.           
138.         //如果同步成功, 共享内存的值为0   
139.         printf("finally: %d\n", *ptr);   
140.     }   
141.   
142.     return 0;   
143. }   

运行结果如下：

本教程示例代码下载请点此链接：http://download.csdn.net/detail/tennysonsky/9029479