Linux进程间通信—信号量

二．信号量（semophore）

信号量是一种计数器，可以控制进程间多个线程或者多个进程对资源的同步访问，它常实现为一种锁机制。实质上，信号量是一个被保护的变量，并且只能通过初始化和两个标准的原子操作（P/V）来访问。（P，V操作也常称为wait(s),signal(s)）

的时候，semaphore与mutex实现的功能就完全相同。许多编程语言也使用semaphore处理多线程同步的问题。一个semaphore会一直存在在内核中，直到某个进程删除它。

l信号量: 解决进程之间的同步与互斥的IPC机制

多个进程同时运行，之间存在关联

　　•同步关系

　　•互斥关系

互斥与同步关系存在的根源在于临界资源

　　•临界资源是在同一个时刻只允许有限个（通常只有一个）进程可以访问（读）或修改（写）的资源

　　　　–硬件资源（处理器、内存、存储器以及其他外围设备等）

　　　　–软件资源（共享代码段，共享结构和变量等）

　　•临界区，临界区本身也会成为临界资源

一个称为信号量的变量

　　•信号量对应于某一种资源，取一个非负的整型值

则意味着目前没有可用的资源

在该信号量下等待资源的进程等待队列

对信号量进行的两个原子操作(PV操作)

　　•P操作

　　•V操作

最简单的信号量是只能取0 和1 两种值，叫做二维信号量

编程步骤：

　　创建信号量或获得在系统已存在的信号量

　　　　•调用semget()函数

　　　　•不同进程使用同一个信号量键值来获得同一个信号量

　　初始化信号量

　　　　•使用semctl()函数的SETVAL操作

　　　　•当使用二维信号量时，通常将信号量初始化为1

　　进行信号量的PV操作

　　　　•调用semop()函数

　　　　•实现进程之间的同步和互斥的核心部分

　　如果不需要信号量，则从系统中删除它

　　　　•使用semclt()函数的IPC_RMID操作

　　　　•在程序中不应该出现对已被删除的信号量的操作

eg. 通过对信号量PV操作，消除父子进程间的竞争条件，使得其调用顺序可控。

1 union semun {

2 int val;

3 struct semid_ds *buf;

4 unsigned short *array;

5 };

7 // 将信号量sem_id设置为init_value

8 int init_sem(int sem_id,int init_value) {

9 union semun sem_union;

10 sem_union.val=init_value;

11 if (semctl(sem_id,0,SETVAL,sem_union)==-1) {

12 perror("Sem init");

13 exit(1);

14 }

15 return 0;

16 }

17 // 删除sem_id信号量

18 int del_sem(int sem_id) {

19 union semun sem_union;

20 if (semctl(sem_id,0,IPC_RMID,sem_union)==-1) {

21 perror("Sem delete");

22 exit(1);

23 }

24 return 0;

25 }

26 // 对sem_id执行p操作

27 int sem_p(int sem_id) {

28 struct sembuf sem_buf;

29 sem_buf.sem_num=0;//信号量编号

30 sem_buf.sem_op=-1;//P操作

31 sem_buf.sem_flg=SEM_UNDO;//系统退出前未释放信号量，系统自动释放

32 if (semop(sem_id,&sem_buf,1)==-1) {

33 perror("Sem P operation");

34 exit(1);

35 }

36 return 0;

37 }

38 // 对sem_id执行V操作

39 int sem_v(int sem_id) {

40 struct sembuf sem_buf;

41 sem_buf.sem_num=0;

42 sem_buf.sem_op=1;//V操作

43 sem_buf.sem_flg=SEM_UNDO;

44 if (semop(sem_id,&sem_buf,1)==-1) {

45 perror("Sem V operation");

46 exit(1);

47 }

48 return 0;

49 }

1 #include <stdio.h>

2 #include <stdlib.h>

3 #include <string.h>

4 #include <sys/types.h>

5 #include <unistd.h>

6 #include <sys/sem.h>

7 #include <sys/ipc.h>

8 #include "sem_com.c"

10 #define DELAY_TIME 3

12 int main() {

13 pid_t pid;

14 // int sem_id;

15 // key_t sem_key;

17 // sem_key=ftok(".",'a');

18 // 以0666且create mode创建一个信号量，返回给sem_id

19 // sem_id=semget(sem_key,1,0666|IPC_CREAT);

20 // 将sem_id设为1

21 // init_sem(sem_id,1);

23 if ((pid=fork())<0) {

24 perror("Fork error!\n");

25 exit(1);

26 } else if (pid==0) {

27 // sem_p(sem_id); // P操作

28 printf("Child running...\n");

29 sleep(DELAY_TIME);

30 printf("Child %d,returned value:%d.\n",getpid(),pid);

31 // sem_v(sem_id); // V操作

32 exit(0);

33 } else {

34 // sem_p(sem_id); // P操作

35 printf("Parent running!\n");

36 sleep(DELAY_TIME);

37 printf("Parent %d,returned value:%d.\n",getpid(),pid);

38 // sem_v(sem_id); // V操作

39 // waitpid(pid,0,0);

40 // del_sem(sem_id);

41 exit(0);

42 }

44 }

在以上程序注释//未去掉时，即没用信号量机制时，其结果为：

显然，此处存在竞争条件。

在以上程序注释//去掉后，即使用信号量机制，其结果为：

由于父子进程采用同一信号量且均执行各自PV操作，故必先等一个进程的V操作后，另一个进程才能工作。

　　信号量又称为信号灯，它是用来协调不同进程间的数据对象的，而最主要的应用是前

一节的共享内存方式的进程间通信。本质上，信号量是一个计数器，它用来记录对某个资源

（如共享内存）的存取状况。一般说来，为了获得共享资源，进程需要执行下列操作：

）测试控制该资源的信号量。

）若此信号量的值为正，则允许进行使用该资源。进程将信号量减1。

）若此信号量为0，则该资源目前不可用，进程进入睡眠状态，直至信号量值大

，进程被唤醒，转入步骤（1）。

）当进程不再使用一个信号量控制的资源时，信号量值加1。如果此时有进程正

在睡眠等待此信号量，则唤醒此进程。

　　维护信号量状态的是Linux内核操作系统而不是用户进程。我们可以从头文

件/usr/src/linux/include　/linux　/sem.h 中看到内核用来维护信号量状态的各个结构的定义。

信号量是一个数据集合，用户可以单独使用这一集合的每个元素。要调用的第一个函数是

semget，用以获得一个信号量ID。

struct sem {

short sempid;

ushort semval;

ushort semncnt;

ushort semzcnt;

}

　　 #include <sys/types.h>

　　 #include <sys/ipc.h>

　　 #include <sys/sem.h>

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

　  key是前面讲过的IPC结构的关键字，flag将来决定是创建新的信号量集合，还是引用

一个现有的信号量集合。nsems是该集合中的信号量数。如果是创建新集合（一般在服务

器中），则必须指定nsems；如果是引用一个现有的信号量集合（一般在客户机中）则将

。

　　 semctl函数用来对信号量进行操作。

　　 int semctl(int semid, int semnum, int cmd, union semun arg);

种不同的操作，实

际编程时可以参照使用。

　　

semop函数自动执行信号量集合上的操作数组。

　　 int semop(int semid, struct sembuf semoparray[], size_t nops);

　　 semoparray是一个指针，它指向一个信号量操作数组。nops规定该数组中操作的数量。

　　下面，我们看一个具体的例子，它创建一个特定的IPC结构的关键字和一个信号量，

建立此信号量的索引，修改索引指向的信号量的值，最后我们清除信号量。在下面的代码中，

函数ftok生成我们上文所说的唯一的IPC关键字。

#include <stdio.h>

#include <sys/types.h>

#include <sys/sem.h>

#include <sys/ipc.h>

void main() {

key_t unique_key;

int id;

struct sembuf lock_it;

union semun options;

int i;

unique_key = ftok(".", 'a');

id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666);

printf("semaphore id=%d\n", id);

options.val = 1;

semctl(id, 0, SETVAL, options);

i = semctl(id, 0, GETVAL, 0);

printf("value of semaphore at index 0 is %d\n", i);

lock_it.sem_num = 0;

lock_it.sem_op = -1;

lock_it.sem_flg = IPC_NOWAIT;

if (semop(id, &lock_it, 1) == -1) {

printf("can not lock semaphore.\n");

exit(1);

}

i = semctl(id, 0, GETVAL, 0);

printf("value of semaphore at index 0 is %d\n", i);

semctl(id, 0, IPC_RMID, 0);

}

semget()

可以使用系统调用semget()创建一个新的信号量集，或者存取一个已经存在的信号量

集：

系统调用：semget();

原型：intsemget(key_t key,int nsems,int semflg);

返回值：如果成功，则返回信号量集的IPC标识符。如果失败，则返回-1：

errno=EACCESS(没有权限)

EEXIST(信号量集已经存在，无法创建)

EIDRM(信号量集已经删除)

ENOENT(信号量集不存在，同时没有使用IPC_CREAT)

ENOMEM(没有足够的内存创建新的信号量集)

ENOSPC(超出限制)

系统调用semget()的第一个参数是关键字值（一般是由系统调用ftok()返回的）。系统

内核将此值和系统中存在的其他的信号量集的关键字值进行比较。打开和存取操作与参数

semflg中的内容相关。IPC_CREAT如果信号量集在系统内核中不存在，则创建信号量集。

IPC_EXCL当和 IPC_CREAT一同使用时，如果信号量集已经存在，则调用失败。如果单独

使用IPC_CREAT，则semget()要么返回新创建的信号量集的标识符，要么返回系统中已经存

在的同样的关键字值的信号量的标识符。如果IPC_EXCL和IPC_CREAT一同使用，则要么

返回新创建的信号量集的标识符，要么返回-1。IPC_EXCL单独使用没有意义。参数nsems

指出了一个新的信号量集中应该创建的信号量的个数。信号量集中最多的信号量的个数是在

linux/sem.h中定义的：

#defineSEMMSL32

下面是一个打开和创建信号量集的程序：

intopen_semaphore_set(key_t keyval,int numsems)

{

intsid;

if(!numsems)

return(-1);

if((sid=semget(mykey,numsems,IPC_CREAT|0660))==-1)

{

return(-1);

}

return(sid);

}

};

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

semop()

系统调用：semop();

调用原型：int semop(int semid,struct sembuf*sops,unsign ednsops);

，如果成功。-1，如果失败：errno=E2BIG(nsops大于最大的ops数目)

EACCESS(权限不够)

EAGAIN(使用了IPC_NOWAIT，但操作不能继续进行)

EFAULT(sops指向的地址无效)

EIDRM(信号量集已经删除)

EINTR(当睡眠时接收到其他信号)

EINVAL(信号量集不存在,或者semid无效)

ENOMEM(使用了SEM_UNDO,但无足够的内存创建所需的数据结构)

ERANGE(信号量值超出范围)

第一个参数是关键字值。第二个参数是指向将要操作的数组的指针。第三个参数是数组

中的操作的个数。参数sops指向由sembuf组成的数组。此数组是在linux/sem.h中定义的：

structsembuf{

ushortsem_num;

shortsem_op;

shortsem_flg;

sem_num将要处理的信号量的个数。

sem_op要执行的操作。

sem_flg操作标志。

如果sem_op是负数，那么信号量将减去它的值。这和信号量控制的资源有关。如果没

有使用IPC_NOWAIT，那么调用进程将进入睡眠状态，直到信号量控制的资源可以使用为

止。如果sem_op是正数，则信号量加上它的值。这也就是进程释放信号量控制的资源。最

，那么调用进程将调用sleep()，直到信号量的值为0。这在一个进程等

待完全空闲的资源时使用。

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

semctl()

系统调用：semctl();

原型：int semctl(int semid,int semnum,int cmd,union semunarg);

返回值：如果成功，则为一个正数。

如果失败，则为-1：errno=EACCESS(权限不够)

EFAULT(arg指向的地址无效)

EIDRM(信号量集已经删除)

EINVAL(信号量集不存在，或者semid无效)

EPERM(EUID没有cmd的权利)

ERANGE(信号量值超出范围)

系统调用semctl用来执行在信号量集上的控制操作。这和在消息队列中的系统调用

msgctl是十分相似的。但这两个系统调用的参数略有不同。因为信号量一般是作为一个信号

量集使用的，而不是一个单独的信号量。所以在信号量集的操作中，不但要知道IPC关键字

值，也要知道信号量集中的具体的信号量。这两个系统调用都使用了参数cmd，它用来指出

要操作的具体命令。两个系统调用中的最后一个参数也不一样。在系统调用msgctl中，最后

一个参数是指向内核中使用的数据结构的指针。我们使用此数据结构来取得有关消息队列的

一些信息，以及设置或者改变队列的存取权限和使用者。但在信号量中支持额外的可选的命

令，这样就要求有一个更为复杂的数据结构。

系统调用semctl()的第一个参数是关键字值。第二个参数是信号量数目。

参数cmd中可以使用的命令如下：

·IPC_STAT读取一个信号量集的数据结构semid_ds，并将其存储在semun中的buf参数

中。

·IPC_SET设置信号量集的数据结构semid_ds中的元素ipc_perm，其值取自semun中的

buf参数。

·IPC_RMID 将信号量集从内存中删除。

·GETALL 用于读取信号量集中的所有信号量的值。

·GETNCNT返回正在等待资源的进程数目。

·GETPID 返回最后一个执行semop操作的进程的PID。

·GETVAL返回信号量集中的一个单个的信号量的值。

·GETZCNT 返回这在等待完全空闲的资源的进程数目。

·SETALL 设置信号量集中的所有的信号量的值。

·SETVAL设置信号量集中的一个单独的信号量的值。

参数arg代表一个semun的实例。semun是在linux/sem.h中定义的：

unionsemun{

intval;

structsemid_ds*buf;

ushort*array;

structseminfo*__buf;

void*__pad;

val当执行SETVAL命令时使用。buf在IPC_STAT/IPC_SET命令中使用。代表了内核中

使用的信号量的数据结构。array在使用GETALL/SETALL命令时使用的指针。

下面的程序返回信号量的值。当使用GETVAL命令时，调用中的最后一个参数被忽略：

intget_sem_val(intsid,intsemnum)

{

return(semctl(sid,semnum,GETVAL,0));

}

下面是一个实际应用的例子：

#defineMAX_PRINTERS5

printer_usage()

{

int x;

for(x=0;x<MAX_PRINTERS;x++)

printf("Printer%d:%d\n\r",x,get_sem_val(sid,x));

}

下面的程序可以用来初始化一个新的信号量值：

void init_semaphore(int sid,int semnum,int initval)

{

union semunsemopts;

semopts.val=initval;

semctl(sid,semnum,SETVAL,semopts);

}

注意系统调用semctl中的最后一个参数是一个联合类型的副本，而不是一个指向联合类

型的指针。