博客园  :: 首页  :: 新随笔  :: 联系 :: 订阅 订阅  :: 管理

Linux进程间通信——使用信号量

Posted on 2015-05-26 16:40  bw_0927  阅读(609)  评论(0)    收藏  举报

http://blog.csdn.net/ljianhui/article/details/10253345

http://blog.csdn.net/ljianhui/article/details/10243617

http://kenby.iteye.com/blog/1165042

信号量也分为POSIX 和 System V两种API

 

信号灯(semaphore)，也叫信号量。它是不同进程间或一个给定进程内部不同线程间同步的机制。信号灯包括posix有名信号灯、 posix基于内存的信号灯(无名信号灯)和System V信号灯(IPC对象)

 

 

一. 信号灯简介

信号灯与其他进程间通信方式不大相同，它主要提供对进程间共享资源访问控制机制。相当于内存中的标志，进程可以根据它判定是否能够访问某些共享资源，同时，进程也可以修改该标志。除了用于访问控制外，还可用于进程同步。

信号灯有以下两种类型：

二值信号灯：最简单的信号灯形式，信号灯的值只能取0或1，类似于互斥锁。 

注：二值信号灯能够实现互斥锁的功能，但两者的关注内容不同。信号灯强调共享资源，只要共享资源可用，其他进程同样可以修改信号灯的值；互斥锁更强调进程，占用资源的进程使用完资源后，必须由进程本身来解锁。

计算信号灯：信号灯的值可以取任意非负值（当然受内核本身的约束）。

 

系统V信号灯是随内核持续的，只有在内核重起或者显示删除一个信号灯集时，该信号灯集才会真正被删除。

 

二. 信号灯的基本操作

对信号灯的操作无非有下面三种类型：

1、打开或创建信号灯 

2、信号灯值操作 

    linux可以增加或减小信号灯的值，相应于对共享资源的释放和占有。具体参见后面的

    semop系统调用。

3、获得或设置信号灯属性： 

    系统中的每一个信号灯集都对应一个struct sem_array结构，该结构记录了信号灯集的各种信息，存在于系统空间。为了设置、获得该信号灯集的各种信息及属性，在用户空间有一个重要的联合结构与之对应，即union semun。

 

三、系统V信号灯API

系统V消息队列API只有三个，使用时需要包括几个头文件：

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

 

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

参数key是一个键值，由ftok获得，唯一标识一个信号灯集.

参数nsems指定信号灯集包含信号灯的数目；

semflg参数是一些标志位。

该调用返回与健值key相对应的信号灯集id

调用返回：成功返回信号灯集描述字，否则返回-1。 

 

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

semid是信号灯集ID，sops数组的每一个sembuf结构都刻画一个在特定信号灯上的操作。

nsops为sops数组的大小。 sembuf结构如下：

struct sembuf {

unsigned short   sem_num; /* semaphore index in array */

short sem_op; /* semaphore operation */

short sem_flg; /* operation flags */

};

sem_num对应集合中的信号灯，0对应第一个信号灯, 以此类推...

sem_flg可取IPC_NOWAIT以及SEM_UNDO两个标志。如果设置了SEM_UNDO标志，那么在进程结束时，相应的操作将被取消，这是比较重要的一个标志位。如果设置了该标志位，那么在进程没有释放共享资源就退出时，内核将代为释放。如果为一个信号灯设置

了该标志，内核都要分配一个sem_undo结构来记录它，为的是确保以后资源能够安全释放。事实上，如果进程退出了，那么它所占用就释放了，但信号灯值却没有改变，此时，信号灯值反映的已经不是资源占有的实际情况，在这种情况下，问题的解决就靠内核来完

成。这有点像僵尸进程，进程虽然退出了，资源也都释放了，但内核进程表中仍然有它的记录，此时就需要父进程调用waitpid来解决问题了。 

sem_op的值大于0，等于0以及小于0确定了对sem_num指定的信号灯进行的三种操作。

这里需要强调的是semop可以同时操作多个信号灯，在实际应用中，对应多种资源的申请或释放。

semop保证操作的原子性，这一点尤为重要。尤其对于多种资源的申请来说，要么一次性获得所有资源，要么放弃申请，要么在不占有任何资源情况下继续等待，这样，一方面避免了资源的浪费；另一方面，避免了进程之间由于申请共享资源造成死锁。 

也许从实际含义上更好理解这些操作：信号灯的当前值记录相应资源目前可用数目；sem_op>0对应相应进程要释放sem_op数目的共享资源；sem_op=0可以用于对共享资源是否已用完的测试；sem_op<0相当于进程要申请-sem_op个共享资源。再联想操作的

原子性，更不难理解该系统调用何时正常返回，何时睡眠等待。 

调用返回：成功返回0，否则返回-1。

 

3) int semctl(int semid，int semnum，int cmd，union semun arg) 

该系统调用实现对信号灯的各种控制操作，参数semid指定信号灯集，参数cmd指定具体的操作类型；参数semnum指定对哪个信号灯操作，只对几个特殊的cmd操作有意义；arg用于设置或返回信号灯信息。 

该系统调用详细信息请参见其手册页，这里只给出参数cmd所能指定的操作。

IPC_STAT 获取信号灯信息，信息由arg.buf返回；

IPC_SET 设置信号灯信息，待设置信息保存在arg.buf中.

GETALL 返回所有信号灯的值，结果保存在arg.array中，参数sennum被忽略；

GETNCNT 返回等待semnum所代表信号灯的值增加的进程数，相当于目前有多少

                进程在等待semnum代表的信号灯所代表的共享资源；

GETPID 返回最后一个对semnum所代表信号灯执行semop操作的进程ID；

GETVAL 返回semnum所代表信号灯的值；

GETZCNT 返回等待semnum所代表信号灯的值变成0的进程数；

SETALL 通过arg.array更新所有信号灯的值；同时，更新与本信号集相关的

                 semid_ds结构的sem_ctime成员；

SETVAL 设置semnum所代表信号灯的值为arg.val；

调用返回：调用失败返回-1，成功返回与cmd相关：

Cmd return value

GETNCNT Semncnt

GETPID Sempid

GETVAL Semval

GETZCNT Semzcnt

 

semctl函数使用到的结构体: 

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 */   //test!!

void *__pad;

};

struct  seminfo {

int semmap;

int semmni;

int semmns;

int semmnu;

int semmsl;

int semopm;

int semume;

int semusz;

int semvmx;

int semaem;

};

 

 

四、范例

这个范例使用信号灯来同步共享内存的操作, 程序创建一块共享内存, 然后父子进程共同修改共享内存. 父子进程采用信号灯来同步操作.

 

 

C代码  收藏代码
  1. #include <stdio.h>  
  2. #include <sys/types.h>  
  3. #include <sys/ipc.h>  
  4. #include <sys/sem.h>  
  5.   
  6. #define SHM_KEY 0x33  
  7. #define SEM_KEY 0x44  
  8.   
  9. union semun {  
  10.     int val;  
  11.     struct semid_ds *buf;  
  12.     unsigned short *array;  
  13. };  
  14.   
  15. int P(int semid)  
  16. {  
  17.     struct sembuf sb;  
  18.     sb.sem_num = 0;  
  19.     sb.sem_op = -1;  
  20.     sb.sem_flg = SEM_UNDO;  
  21.       
  22.     if(semop(semid, &sb, 1) == -1) {  
  23.         perror("semop");  
  24.         return -1;  
  25.     }  
  26.     return 0;  
  27. }  
  28.   
  29. int V(int semid)  
  30. {  
  31.     struct sembuf sb;  
  32.     sb.sem_num = 0;  
  33.     sb.sem_op = 1;  
  34.     sb.sem_flg = SEM_UNDO;  
  35.       
  36.     if(semop(semid, &sb, 1) == -1) {  
  37.         perror("semop");  
  38.         return -1;  
  39.     }  
  40.     return 0;  
  41. }  
  42.   
  43. int main(int argc, char **argv)  
  44. {  
  45.     pid_t pid;  
  46.     int i, shmid, semid;  
  47.     int *ptr;  
  48.     union semun semopts;  
  49.   
  50.     /* 创建一块共享内存, 存一个int变量 */  
  51.     if ((shmid = shmget(SHM_KEY, sizeof(int), IPC_CREAT | 0600)) == -1) {  
  52.         perror("msgget");  
  53.     }  
  54.   
  55.     /* 将共享内存映射到进程, fork后子进程可以继承映射 */  
  56.     if ((ptr = (int *)shmat(shmid, NULL, 0)) == (void *)-1) {  
  57.         perror("shmat");  
  58.     }  
  59.     *ptr = 0;  
  60.   
  61.     /* 创建一个信号量用来同步共享内存的操作 */  
  62.     if ((semid = semget(SEM_KEY, 1, IPC_CREAT | 0600)) == -1) {  
  63.         perror("semget");  
  64.     }  
  65.   
  66.     /* 初始化信号量 */  
  67.     semopts.val = 1;  
  68.     if (semctl(semid, 0, SETVAL, semopts) < 0) {  
  69.         perror("semctl");  
  70.     }  
  71.   
  72.     if ((pid = fork()) < 0) {  
  73.         perror("fork");  
  74.     } else if (pid == 0) {      /* Child */  
  75.         /* 子进程对共享内存加1 */  
  76.         for (i = 0; i < 100000; i++) {  
  77.             P(semid);  
  78.             (*ptr)++;  
  79.             V(semid);  
  80.             printf("child: %d\n", *ptr);  
  81.         }  
  82.     } else {                    /* Parent */  
  83.         /* 父进程对共享内存减1 */  
  84.         for (i = 0; i < 100000; i++) {  
  85.             P(semid);  
  86.             (*ptr)--;  
  87.             V(semid);  
  88.             printf("parent: %d\n", *ptr);  
  89.         }  
  90.         waitpid(pid);  
  91.         /* 如果同步成功, 共享内存的值为0 */  
  92.         printf("finally: %d\n", *ptr);  
  93.     }  
  94.   
  95.     return 0;  
  96. }  

 

五. 区别 System V信号量和Posix信号量
信号量有两种实现：传统的System V信号量和新的POSIX信号量。它们所提供的函数很容易被区分：对于所有System V信号量函数，在它们的名字里面没有下划线。例如，应该是semget()而不是sem_get()。然而，所有的的POSIX信号量函数都有一个下划线。下面列出了它们提供的所有函数清单：
Systm V POSIX
semctl() sem_getvalue()
semget() sem_post()
semop() sem_timedwait()
  sem_trywait()
  sem_wait()
   
  sem_destroy()
  sem_init()
   
  sem_close()
  sem_open()
  sem_unlink()


另外一个区别是，对于POSIX信号量，你可以有命名的信号量，例如，信号量有一个文件关联它们，对于最后三个函数，被用来创建，关闭和删除这样一个命名的信号量。
而sem_init()和sem_destroy()仅仅供非命名信号量使用。
他们是有关信号量的两组程序设计接口函数。POSIX信号量来源于POSIX技术规范的实时扩展方案(POSIX Realtime Extension)，常用于线程；system v信号量，常用于进程的同步。
这两者非常相近，但它们使用的函数调用各不相同。
前一种的头文件为semaphore.h，函数调用为sem_init(),sem_wait(),sem_post(),sem_destory()等等。
后一种头文件为<sys/sem.h>,函数调用为semctl(),semget(),semop()等函数。
 
更详细地请看 man sem_overview
 
总结:
System V的信号量一般用于进程同步, 且是内核持续的, api为
semget
semctl
semop
Posix的有名信号量一般用于进程同步, 有名信号量是内核持续的. 有名信号量的api为
sem_open
sem_close
sem_unlink

Posix的无名信号量一般用于线程同步, 无名信号量是进程持续的, 无名信号量的api为

sem_init

sem_destroy

 

下面一个范例使用Posix的有名信号量来同步父子进程的共享内存操作:

 

 

C代码  收藏代码
  1. #include <stdio.h>  
  2. #include <sys/types.h>  
  3. #include <sys/ipc.h>  
  4. #include <semaphore.h>  
  5. #include <fcntl.h>           /* For O_* constants */  
  6. #include <sys/stat.h>        /* For mode constants */  
  7. #include <stdlib.h>  
  8.   
  9. #define SHM_KEY 0x33  
  10.   
  11. int main(int argc, char **argv)  
  12. {  
  13.     pid_t pid;  
  14.     int i, shmid;  
  15.     int *ptr;  
  16.     sem_t *sem;  
  17.   
  18.     /* 创建一块共享内存, 存一个int变量 */  
  19.     if ((shmid = shmget(SHM_KEY, sizeof(int), IPC_CREAT | 0600)) == -1) {  
  20.         perror("msgget");  
  21.     }  
  22.   
  23.     /* 将共享内存映射到进程, fork后子进程可以继承映射 */  
  24.     if ((ptr = (int *)shmat(shmid, NULL, 0)) == (void *)-1) {  
  25.         perror("shmat");  
  26.     }  
  27.     *ptr = 0;  
  28.   
  29.     /* posix的有名信号量是kernel persistent的 
  30.      * 调用sem_unlink删除以前的信号量 */  
  31.     sem_unlink("/mysem");  
  32.   
  33.     /* 创建新的信号量, 初值为1, sem_open会创建共享内存 
  34.      * 所以信号量是内核持续的 */  
  35.     if ((sem = sem_open("/mysem", O_CREAT, 0600, 1)) == SEM_FAILED) {  
  36.         perror("sem_open");  
  37.     }  
  38.   
  39.     if ((pid = fork()) < 0) {  
  40.         perror("fork");  
  41.     } else if (pid == 0) {      /* Child */  
  42.         /* 子进程对共享内存加1 */  
  43.         for (i = 0; i < 100000; i++) {  
  44.             sem_wait(sem);  
  45.             (*ptr)++;  
  46.             sem_post(sem);  
  47.             printf("child: %d\n", *ptr);  
  48.         }  
  49.     } else {                    /* Parent */  
  50.         /* 父进程对共享内存减1 */  
  51.         for (i = 0; i < 100000; i++) {  
  52.             sem_wait(sem);  
  53.             (*ptr)--;  
  54.             sem_post(sem);  
  55.             printf("parent: %d\n", *ptr);  
  56.         }  
  57.         waitpid(pid);  
  58.         /* 如果同步成功, 共享内存的值为0 */  
  59.         printf("finally: %d\n", *ptr);  
  60.         sem_unlink("/mysem");     //父进程创建，父进程删除
  61.     }  
  62.   
  63.     return 0;  
  64. }  

 

========================================================================

 

这篇文章将讲述别一种进程间通信的机制——信号量。注意请不要把它与之前所说的信号混淆起来，信号与信号量是不同的两种事物。有关信号的更多内容，可以阅读我的另一篇文章：Linux进程间通信——使用信号。下面就进入信号量的讲解。

 
一、什么是信号量
为了防止出现因多个程序同时访问一个共享资源而引发的一系列问题，我们需要一种方法，它可以通过生成并使用令牌来授权，在任一时刻只能有一个执行线程访问代码的临界区域。临界区域是指执行数据更新的代码需要独占式地执行。而信号量就可以提供这样的一种访问机制，让一个临界区同一时间只有一个线程在访问它，也就是说信号量是用来调协进程对共享资源的访问的。
 
信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待（即P(信号变量))和发送（即V(信号变量))信息操作。最简单的信号量是只能取0和1的变量，这也是信号量最常见的一种形式，叫做二进制信号量。而可以取多个正整数的信号量被称为通用信号量。这里主要讨论二进制信号量。
 
二、信号量的工作原理
由于信号量只能进行两种操作等待和发送信号，即P(sv)和V(sv),他们的行为是这样的：
P(sv)：如果sv的值大于零，就给它减1；如果它的值为零，就挂起该进程的执行
V(sv)：如果有其他进程因等待sv而被挂起，就让它恢复运行，如果没有进程因等待sv而挂起，就给它加1.
 
举个例子，就是两个进程共享信号量sv，一旦其中一个进程执行了P(sv)操作，它将得到信号量，并可以进入临界区，使sv减1。而第二个进程将被阻止进入临界区，因为当它试图执行P(sv)时，sv为0，它会被挂起以等待第一个进程离开临界区域并执行V(sv)释放信号量，这时第二个进程就可以恢复执行。
 
三、Linux的信号量机制
Linux提供了一组精心设计的信号量接口来对信号进行操作，它们不只是针对二进制信号量，下面将会对这些函数进行介绍，但请注意，这些函数都是用来对成组的信号量值进行操作的。它们声明在头文件sys/sem.h中。
 
1、semget函数
它的作用是创建一个新信号量或取得一个已有信号量，原型为：
[cpp] view plaincopyprint?
 

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

参数key是一个键值，由ftok获得，唯一标识一个信号灯集.

参数nsems指定信号灯集包含信号灯的数目；

semflg参数是一些标志位。

该调用返回与健值key相对应的信号灯集id

调用返回：成功返回信号灯集描述字，否则返回-1。 

 

  1. int semget(key_t key, int num_sems, int sem_flags);  
第一个参数key是整数值（唯一非零），不相关的进程可以通过它访问一个信号量，它代表程序可能要使用的某个资源，程序对所有信号量的访问都是间接的，程序先通过调用semget函数并提供一个键，再由系统生成一个相应的信号标识符（semget函数的返回值），只有semget函数才直接使用信号量键，所有其他的信号量函数使用由semget函数返回的信号量标识符。如果多个程序使用相同的key值，key将负责协调工作。
 
第二个参数num_sems指定需要的信号量数目，它的值几乎总是1。
 
第三个参数sem_flags是一组标志，当想要当信号量不存在时创建一个新的信号量，可以和值IPC_CREAT做按位或操作。设置了IPC_CREAT标志后，即使给出的键是一个已有信号量的键，也不会产生错误。而IPC_CREAT | IPC_EXCL则可以创建一个新的，唯一的信号量，如果信号量已存在，返回一个错误。
 
semget函数成功返回一个相应信号标识符（非零），失败返回-1.
 
2、semop函数
它的作用是改变信号量的值，原型为：
[cpp] view plaincopyprint?
 
  1. int semop(int sem_id, struct sembuf *sem_opa, size_t num_sem_ops);  
sem_id是由semget返回的信号量标识符，sembuf结构的定义如下：
 
[cpp] view plaincopyprint?
 
  1. struct sembuf{  
  2.     short sem_num;//除非使用一组信号量，否则它为0  
  3.     short sem_op;//信号量在一次操作中需要改变的数据，通常是两个数，一个是-1，即P（等待）操作，  
  4.                     //一个是+1，即V（发送信号）操作。  
  5.     short sem_flg;//通常为SEM_UNDO,使操作系统跟踪信号，  
  6.                     //并在进程没有释放该信号量而终止时，操作系统释放信号量  
  7. };  
3、semctl函数
该函数用来直接控制信号量信息，它的原型为：
[cpp] view plaincopyprint?
 
  1. int semctl(int sem_id, int sem_num, int command, ...);  
如果有第四个参数，它通常是一个union semum结构，定义如下：
 
[cpp] view plaincopyprint?
 
  1. union semun{  
  2.     int val;  
  3.     struct semid_ds *buf;  
  4.     unsigned short *arry;  
  5. };  
前两个参数与前面一个函数中的一样，command通常是下面两个值中的其中一个
SETVAL：用来把信号量初始化为一个已知的值。 这个值通过union semun中的val成员设置，其作用是在信号量第一次使用前对它进行设置。
IPC_RMID：用于删除一个已经无需继续使用的信号量标识符。
 
四、进程使用信号量通信
下面使用一个例子来说明进程间如何使用信号量来进行通信，这个例子是两个相同的程序同时向屏幕输出数据，我们可以看到如何使用信号量来使两个进程协调工作，使同一时间只有一个进程可以向屏幕输出数据。注意，如果程序是第一次被调用（为了区分，第一次调用程序时带一个要输出到屏幕中的字符作为一个参数），则需要调用set_semvalue函数初始化信号并将message字符设置为传递给程序的参数的第一个字符，同时第一个启动的进程还负责信号量的删除工作。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。
 
在main函数中调用semget来创建一个信号量，该函数将返回一个信号量标识符，保存于全局变量sem_id中，然后以后的函数就使用这个标识符来访问信号量。
 
源文件为seml.c，代码如下：
 
[cpp] view plaincopyprint?
 
  1. #include <unistd.h>  
  2. #include <sys/types.h>  
  3. #include <sys/stat.h>  
  4. #include <fcntl.h>  
  5. #include <stdlib.h>  
  6. #include <stdio.h>  
  7. #include <string.h>  
  8. #include <sys/sem.h>  
  9.   
  10. union semun  
  11. {  
  12.     int val;  
  13.     struct semid_ds *buf;  
  14.     unsigned short *arry;  
  15. };  
  16.   
  17. static int sem_id = 0;  
  18.   
  19. static int set_semvalue();  
  20. static void del_semvalue();  
  21. static int semaphore_p();  
  22. static int semaphore_v();  
  23.   
  24. int main(int argc, char *argv[])  
  25. {  
  26.     char message = 'X';  
  27.     int i = 0;  
  28.   
  29.     //创建信号量  
  30.     sem_id = semget((key_t)1234, 1, 0666 | IPC_CREAT);  
  31.   
  32.     if(argc > 1)  
  33.     {  
  34.         //程序第一次被调用，初始化信号量  
  35.         if(!set_semvalue())  
  36.         {  
  37.             fprintf(stderr, "Failed to initialize semaphore\n");  
  38.             exit(EXIT_FAILURE);  
  39.         }  
  40.         //设置要输出到屏幕中的信息，即其参数的第一个字符  
  41.         message = argv[1][0];  
  42.         sleep(2);  
  43.     }  
  44.     for(i = 0; i < 10; ++i)  
  45.     {  
  46.         //进入临界区  
  47.         if(!semaphore_p())  
  48.             exit(EXIT_FAILURE);  
  49.         //向屏幕中输出数据  
  50.         printf("%c", message);  
  51.         //清理缓冲区，然后休眠随机时间  
  52.         fflush(stdout);  
  53.         sleep(rand() % 3);  
  54.         //离开临界区前再一次向屏幕输出数据  
  55.         printf("%c", message);  
  56.         fflush(stdout);  
  57.         //离开临界区，休眠随机时间后继续循环  
  58.         if(!semaphore_v())  
  59.             exit(EXIT_FAILURE);  
  60.         sleep(rand() % 2);  
  61.     }  
  62.   
  63.     sleep(10);  
  64.     printf("\n%d - finished\n", getpid());  
  65.   
  66.     if(argc > 1)  
  67.     {  
  68.         //如果程序是第一次被调用，则在退出前删除信号量  
  69.         sleep(3);  
  70.         del_semvalue();  
  71.     }  
  72.     exit(EXIT_SUCCESS);  
  73. }  
  74.   
  75. static int set_semvalue()  
  76. {  
  77.     //用于初始化信号量，在使用信号量前必须这样做  
  78.     union semun sem_union;  
  79.   
  80.     sem_union.val = 1;  
  81.     if(semctl(sem_id, 0, SETVAL, sem_union) == -1)  
  82.         return 0;  
  83.     return 1;  
  84. }  
  85.   
  86. static void del_semvalue()  
  87. {  
  88.     //删除信号量  
  89.     union semun sem_union;  
  90.   
  91.     if(semctl(sem_id, 0, IPC_RMID, sem_union) == -1)  
  92.         fprintf(stderr, "Failed to delete semaphore\n");  
  93. }  
  94.   
  95. static int semaphore_p()  
  96. {  
  97.     //对信号量做减1操作，即等待P（sv）  
  98.     struct sembuf sem_b;  
  99.     sem_b.sem_num = 0;  
  100.     sem_b.sem_op = -1;//P()  
  101.     sem_b.sem_flg = SEM_UNDO;  
  102.     if(semop(sem_id, &sem_b, 1) == -1)  
  103.     {  
  104.         fprintf(stderr, "semaphore_p failed\n");  
  105.         return 0;  
  106.     }  
  107.     return 1;  
  108. }  
  109.   
  110. static int semaphore_v()  
  111. {  
  112.     //这是一个释放操作，它使信号量变为可用，即发送信号V（sv）  
  113.     struct sembuf sem_b;  
  114.     sem_b.sem_num = 0;  
  115.     sem_b.sem_op = 1;//V()  
  116.     sem_b.sem_flg = SEM_UNDO;  
  117.     if(semop(sem_id, &sem_b, 1) == -1)  
  118.     {  
  119.         fprintf(stderr, "semaphore_v failed\n");  
  120.         return 0;  
  121.     }  
  122.     return 1;  
  123. }  
运行结果如下：
 
注：这个程序的临界区为main函数for循环不的semaphore_p和semaphore_v函数中间的代码。
 
例子分析 ：同时运行一个程序的两个实例，注意第一次运行时，要加上一个字符作为参数，例如本例中的字符‘O’，它用于区分是否为第一次调用，同时这个字符输出到屏幕中。因为每个程序都在其进入临界区后和离开临界区前打印一个字符，所以每个字符都应该成对出现，正如你看到的上图的输出那样。在main函数中循环中我们可以看到，每次进程要访问stdout（标准输出），即要输出字符时，每次都要检查信号量是否可用（即stdout有没有正在被其他进程使用）。所以，当一个进程A在调用函数semaphore_p进入了临界区，输出字符后，调用sleep时，另一个进程B可能想访问stdout，但是信号量的P请求操作失败，只能挂起自己的执行，当进程A调用函数semaphore_v离开了临界区，进程B马上被恢复执行。然后进程A和进程B就这样一直循环了10次。
 
五、对比例子——进程间的资源竞争
看了上面的例子，你可能还不是很明白，不过没关系，下面我就以另一个例子来说明一下，它实现的功能与前面的例子一样，运行方式也一样，都是两个相同的进程，同时向stdout中输出字符，只是没有使用信号量，两个进程在互相竞争stdout。它的代码非常简单，文件名为normalprint.c，代码如下：
 
[cpp] view plaincopyprint?
 
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3.   
  4. int main(int argc, char *argv[])  
  5. {  
  6.     char message = 'X';  
  7.     int i = 0;    
  8.     if(argc > 1)  
  9.         message = argv[1][0];  
  10.     for(i = 0; i < 10; ++i)  
  11.     {  
  12.         printf("%c", message);  
  13.         fflush(stdout);  
  14.         sleep(rand() % 3);  
  15.         printf("%c", message);  
  16.         fflush(stdout);  
  17.         sleep(rand() % 2);  
  18.     }  
  19.     sleep(10);  
  20.     printf("\n%d - finished\n", getpid());  
  21.     exit(EXIT_SUCCESS);  
  22. }  
运行结果如下：
 
例子分析：
从上面的输出结果，我们可以看到字符‘X’和‘O’并不像前面的例子那样，总是成对出现，因为当第一个进程A输出了字符后，调用sleep休眠时，另一个进程B立即输出并休眠，而进程A醒来时，再继续执行输出，同样的进程B也是如此。所以输出的字符就是不成对的出现。这两个进程在竞争stdout这一共同的资源。通过两个例子的对比，我想信号量的意义和使用应该比较清楚了。
 
六、信号量的总结
信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待（即P(信号变量))和发送（即V(信号变量))信息操作。我们通常通过信号来解决多个进程对同一资源的访问竞争的问题，使在任一时刻只能有一个执行线程访问代码的临界区域，也可以说它是协调进程间的对同一资源的访问权，也就是用于同步进程的。