转载自：http://blog.csdn.net/ljianhui/article/details/10243617
http://blog.chinaunix.net/uid-21273878-id-1828730.html
基础部分讲解是照搬第一个blog的，为了加深理解把找了第二个blog，并把代码稍微改了一下。
这篇文章将讲述别一种进程间通信的机制——信号量。注意请不要把它与之前所说的信号混淆起来，信号与信号量是不同的两种事物。有关信号的更多内容，可以阅读我的另一篇文章：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函数
它的作用是创建一个新信号量或取得一个已有信号量，原型为：
第一个参数key是整数值（唯一非零），不相关的进程可以通过它访问一个信号量，它代表程序可能要使用的某个资源，程序对所有信号量的访问都是间接的，程序先通过调用semget函数并提供一个键，再由系统生成一个相应的信号标识符（semget函数的返回值），只有semget函数才直接使用信号量键，所有其他的信号量函数使用由semget函数返回的信号量标识符。如果多个程序使用相同的key值，key将负责协调工作。
第二个参数num_sems指定需要的信号量数目，它的值几乎总是1。
第三个参数sem_flags是一组标志，当想要当信号量不存在时创建一个新的信号量，可以和值IPC_CREAT做按位或操作。设置了IPC_CREAT标志后，即使给出的键是一个已有信号量的键，也不会产生错误。而IPC_CREAT | IPC_EXCL则可以创建一个新的，唯一的信号量，如果信号量已存在，返回一个错误。
semget函数成功返回一个相应信号标识符（非零），失败返回-1.
2、semop函数
它的作用是改变信号量的值，原型为：
sem_id是由semget返回的信号量标识符，sembuf结构的定义如下：
3、semctl函数
该函数用来直接控制信号量信息，它的原型为：
如果有第四个参数，它通常是一个union semum结构，定义如下：
前两个参数与前面一个函数中的一样，command通常是下面两个值中的其中一个
SETVAL：用来把信号量初始化为一个已知的值。p 这个值通过union semun中的val成员设置，其作用是在信号量第一次使用前对它进行设置。
IPC_RMID：用于删除一个已经无需继续使用的信号量标识符。
四、进程使用信号量通信
下面使用一个例子来说明进程间如何使用信号量来进行通信，这个例子是两个相同的程序同时向屏幕输出数据，我们可以看到如何使用信号量来使两个进程协调工作，使同一时间只有一个进程可以向屏幕输出数据。注意，如果程序是第一次被调用（为了区分，第一次调用程序时带一个要输出到屏幕中的字符作为一个参数），则需要调用set_semvalue函数初始化信号并将message字符设置为传递给程序的参数的第一个字符，同时第一个启动的进程还负责信号量的删除工作。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。
在main函数中调用semget来创建一个信号量，该函数将返回一个信号量标识符，保存于全局变量sem_id中，然后以后的函数就使用这个标识符来访问信号量。
源文件为seml.c，代码如下：
运行结果如下：
注：这个程序的临界区为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，代码如下：
运行结果如下：
例子分析：
从上面的输出结果，我们可以看到字符‘X’和‘O’并不像前面的例子那样，总是成对出现，因为当第一个进程A输出了字符后，调用sleep休眠时，另一个进程B立即输出并休眠，而进程A醒来时，再继续执行输出，同样的进程B也是如此。所以输出的字符就是不成对的出现。这两个进程在竞争stdout这一共同的资源。通过两个例子的对比，我想信号量的意义和使用应该比较清楚了。
六、信号量的总结
信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待（即P(信号变量))和发送（即V(信号变量))信息操作。我们通常通过信号来解决多个进程对同一资源的访问竞争的问题，使在任一时刻只能有一个执行线程访问代码的临界区域，也可以说它是协调进程间的对同一资源的访问权，也就是用于同步进程的。
=============
=============
=============
=========分割线====
=============
=============
=============
=============
===
从以上代码例子感觉有点难理解信号量如何使得两个进程协同工作，下面是另一个博客的代码，使用共享内存+信号量实现的小程序：
①写入方代码：
#include "shm_mem.h"
int main(int argc, char** argv)
{
int semid, shmid;
char *shmaddr;
char write_str[SHM_SIZE];
char *ret;
if((shmid = creatshm(".", 57, SHM_SIZE)) == -1) //创建或者获取共享内存
return -1;
/*建立进程和共享内存连接*/
if((shmaddr = shmat(shmid, (char*)0, 0)) == (char *)-1){
perror("attch shared memory error!\n");
exit(1);
}
if((semid = creatsem("./", 39, 1, 1)) == -1)//创建信号量
return -1;
//源博客这里没有初始化信号量，在之前只是创建信号量而已
union semun sem_union;
sem_union.val = 1;
semctl(semid, 0, SETVAL, sem_union);
while(1){
//wait_sem(semid, 0);//等待信号量可以被获取
//源博客代码因为没有初始化，所以要等待信号量变为0，不然在获取信号量会出错。
//还有就是源博客semop操作是IPC_NOWAIT，所以不会得不到信号量会立马返回，不会阻塞，
//所以在wait_sem中是busy-wait,然而感觉还是设为阻塞稍微好一些。
sem_p(semid, 0); //获取信号量
/***************写共享内存***************************************************/
printf("write : ");
ret = fgets(write_str, 1024, stdin);
if(write_str[0] == '#') // '#'结束读写进程
break;
int len = strlen(write_str);
write_str[len] = '\0';
strcpy(shmaddr, write_str);
/****************************************************************************/
sem_v(semid, 0); //释放信号量
//usleep(1000); //本进程睡眠.
}
sem_delete(semid); //把semid指定的信号集从系统中删除
deleteshm(shmid); //从系统中删除shmid标识的共享内存
return 0;
}
②读入方代码：
#include "shm_mem.h"
int main(int argc, char** argv)
{
int semid, shmid;
char *shmaddr;
printf("What!!!!!!!!!!!\n");
if((shmid = creatshm(".", 57, SHM_SIZE)) == -1)
return -1;
if((shmaddr = shmat(shmid, (char*)0, 0)) == (char *)-1){
perror("attch shared memory error!\n");
exit(1);
}
if((semid = opensem("./", 39)) == -1)
return -1;
printf("read start....................\n");
while(1){
printf("read : ");
//wait_sem(semid, 0); //等待信号量可以获取
if(sem_p(semid, 0) == -1) //获取信号量失败退出。当写者写入'#'时表示退出
break;
printf("%s", shmaddr);
sem_v(semid, 0);
//usleep(1000);
}
return 0;
}
③函数定义：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <error.h>
#define SHM_SIZE 1024
union semun{
int val;
struct semid_ds *buf;
unsigned short *array;
struct seminfo *buf_info;
void *pad;
};
/* 创建信号量函数*/
int creatsem(const char *pathname, int proj_id, int members, int init_val)
{
key_t msgkey;
int index, sid;
union semun semopts;
if((msgkey = ftok(pathname, proj_id)) == -1){
perror("ftok error!\n");
return -1;
}
if((sid = semget(msgkey, members, IPC_CREAT|0666)) == -1){
perror("semget call failed.\n");
return -1;
}
semopts.val = init_val;
for(index = 0; index < members; index++){
semctl(sid, index, SETVAL, semopts);
}
return sid;
}
int opensem(const char *pathname, int proj_id)
{
key_t msgkey;
int sid;
if((msgkey = ftok(pathname, proj_id)) == -1){
perror("ftok error!\n");
return -1;
}
if((sid = semget(msgkey, 0, 0666)) == -1){
perror("open semget call failed.\n");
return -1;
}
return sid;
}
/* p操作, 获取信号量*/
int sem_p(int semid, int index)
{
//struct sembuf sbuf = {0, -1, SEM_UNDO};
/*
struct sembuf sbuf = {0, -1, IPC_NOWAIT};
if(index < 0){
perror("index of array cannot equals a minus value!\n");
return -1;
}
sbuf.sem_num = index;
if(semop(semid, &sbuf, 1) == -1){
perror("A wrong operation to semaphore occurred!\n");
return -1;
}
return 0;
*/
struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = -1;//P()
sem_b.sem_flg = SEM_UNDO;
if(semop(semid, &sem_b, 1) == -1)
{
perror("A wrong operation to semaphore occurred!\n");
return -1;
}
return 0;
}
/* V操作, 释放信号量*/
int sem_v(int semid, int index)
{
//struct sembuf sbuf = {0, 1, SEM_UNDO};
/*
<span style="color:#ff0000;">struct sembuf sbuf = {0, 1, IPC_NOWAIT};</span>
if(index < 0){
perror("index of array cannot equals a minus value!\n");
return -1;
}
sbuf.sem_num = index;
if(semop(semid, &sbuf, 1) == -1){
perror("A wrong operation to semaphore occurred!\n");
return -1;
}
return 0;
*/
struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = 1;//V()
sem_b.sem_flg = <span style="color:#cc0000;">SEM_UNDO</span>;
if(semop(semid, &sem_b, 1) == -1)
{
perror("A wrong operation to semaphore occurred!\n");
return -1;
}
return 0;
}
/* 删除信号量几*/
int sem_delete(int semid)
{
return (semctl(semid, 0, IPC_RMID));
}
/* 等待信号量为1*/
int wait_sem(int semid, int index)
{
while(semctl(semid, index, GETVAL, 0) == 0)
{
//wait_num++;
usleep(500);
}
//printf("wait_num = %x\n", wait_num);
return 1;
}
/* 创建共享内存*/
int creatshm(char *pathname, int proj_id, size_t size)
{
key_t shmkey;
int sid;
if((shmkey = ftok(pathname, proj_id)) == -1){
perror("ftok error!\n");
return -1;
}
if((sid = shmget(shmkey, size, IPC_CREAT|0666)) == -1){
perror("shm call failed!\n");
return -1;
}
return sid;
}
/* 删除共享内存*/
int deleteshm(int sid)
{
void *p = NULL;
return (shmctl(sid, IPC_RMID, p));
}
结果如下：
结果解释：
因为我把usleep注释掉了，要是两个进程没有协同工作的话，那么读入方应该是个死循环，而从结果上看，显然在写入方没有输入的时候读入方阻塞等待，也就是说信号量使得两个进程协同工作了。
1725
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
