新手上路系列10：信号量与信号通信

1、信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待（即P)和发送（即V)信息操作。最简单的信号量是只能取0和1的变量，这也是信号量最

常见的一种形式，叫做二进制信号量。信号量的出现，主要是由于需要一种这样一种访问机制，让一个临界区同一时间只有一个进程在访问它，也就是说信号量是用来协调进程

对共享资源的访问。由于信号量只能进行两种操作等待和发送信号，即P(sv)和V(sv),他们的行为是这样的：

P(sv)：如果sv的值大于零，就给它减1；如果它的值为零，就挂起该进程的执行；

V(sv)：如果有其他进程因等待sv而被挂起，就让它恢复运行，如果没有进程因等待sv而挂起，就给它加1；

接下来就是信息量的一些基本操作：

1）创建：int semget(key_t key, int num_sems, int sem_flags);  该函数成功则返回一个响应信号标志符（非零），失败返回-1；

2）操作：int semop(int sem_id, struct sembuf *sem_opa, size_t num_sem_ops);  它的作用是改变信号量 值，主要要提到的是它的第二个参数，一个sembuf 结构，它

将在下面的程序展示。

3）控制：int semctl(int sem_id, int sem_num, int command, ...);  该函数用来直接控制信号量的信息，如果有第四个参数，他通常是一个union semum 结构。第三个参

数comman 通常是下面两个值中的一个：

SETVAL：用来把信号量初始化为一个已知的值。p 这个值通过union semun中的val成员设置，其作用是在信号量第一次使用前对它进行设置。

IPC_RMID：用于删除一个已经无需继续使用的信号量标识符。

接下来，介绍一个利用信息量以及上一篇博客中提到的共享内存的知识做的一个小程序，卖票系统。主要功能是模拟一个卖票的机制，开几个终端来逐一获取票，用信息量

来控制取票的次序。

首先，这个系统的头文件：

#ifndef __SEMAPHORE_H__
#define __SEMAPHORE_H__

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

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  *
4000
__buf;  /* Buffer for IPC_INFO(Linux specific) */
};

// 信号量的初始化函数
int sem_init(int sem_id)
{
union semun sem;
sem.val = 1;
int ret = semctl(sem_id, 0, SETVAL, sem);
return ret;
}

// 信号量的 P 操作
int sem_p(int sem_id)
{
struct sembuf sem;
sem.sem_num = 0;
sem.sem_op  = -1;
sem.sem_flg = SEM_UNDO;
int ret = semop(sem_id, &sem,1);

return ret;
}

// 信号量的 v 操作
int sem_v(int sem_id)
{
struct sembuf sem;
sem.sem_num = 0;
sem.sem_op  = 1;
sem.sem_flg = SEM_UNDO;
int ret = semop(sem_id, &sem,1);

return ret;
}

// 销毁信号量
int sem_del(int sem_id)
{
int ret = semctl(sem_id, 0, IPC_RMID);
return ret;
}

#endif // __SEMAPHORE_H__

然后就是主程序了：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <string.h>
#include <time.h>
#include "semaphore.h"

typedef struct _shm
{
int flag;
int ticket;
}SHM;

void sellTicket(SHM* pshm, int sem_id)
{

while (1)
{
int time = rand() % 10 + 1;
usleep(time*100000);

// 信号量的P操作
sem_p (sem_id);

if (pshm->ticket == 0)  // 票卖完
{
sem_v (sem_id);
break;
}

printf ("卖掉一张票，座位号是 : %d\n", pshm->ticket);
pshm->ticket--;

sem_v (sem_id);
}
}

int main(int argc, char **argv)
{
srand ((unsigned int)time(NULL));

// 1、创建或者获取一个共享内存
int shmid = shmget((key_t)1234, sizeof(SHM), 0666 | IPC_CREAT);
if (shmid == -1)
{
perror ("shmget");
return -1;
}

// 创建一个信号量
int sem_id = semget((key_t)5678, 1, 0666 | IPC_CREAT);
if (sem_id== -1)
{
perror ("semget");
return -1;
}

// 2、将共享内存映射到当前的进程空间
SHM* pshm = (SHM*)shmat(shmid, NULL, 0);
if(pshm == (SHM*)-1)
{
perror ("shmat");
return -1;
}

// 如果命令行参数等于2 负责对共享内存和信号量进行初始化
if (argc == 2)
{
pshm->ticket = 100;
sem_init(sem_id);
}

// 开始卖票
sellTicket(pshm, sem_id);

// 如果命令行参数等于2 负责对共享内存和信号量进行删除
if (argc == 2)
{
shmctl(shmid, IPC_RMID, NULL);
sem_del(sem_id);
}

return 0;
}

2、信息通信：与信息量不同，信息量属于进程同步的内容，而信息通信却是属于进程间通信（IPC）。首先，我们可以在终端输入这样一条命令：kill -l ；我们可以获得64

个信号编号。常用的信号都会在这边。



1、）signal：  typedef  void (*sighandler_t)(int);   sighandler_t signal(int signum, sighandler_t handler)；向一个信号处理函数发送一个信号：

#include <stdio.h>
#include <signal.h>

// 信号处理函数
void handle(int signum)
{
printf ("捕捉到一个信号 %d\n", signum);
}

int main()
{

signal(SIGINT, handle);
signal(SIGTERM, handle);

while (1);
return 0;
}

该函数能够捕捉SIGINT与SIGTERM这2个信号，它们分别是由终端上的CTRL+C 与 "kill" 命令产生的，所以该进程的终止方式除了关闭终端就只有 "kill -9" 这条命令了。

2、）kill：int kill(pid_t pid, int sig)；和上个函数类似，功能是向一个进程发送一个信号。

3、）alarm： unsigned int alarm(unsigned int seconds)；定时器函数，定时单位为秒，并且定时器是一次性的，若要重复使用必须要进行定时器充值操作。

#include <stdio.h>
#include <signal.h>

// 信号处理函数
void handle(int signum)
{
printf ("hello world\n");

// 定时器重置
alarm(2);
}

int main()
{
// 定时器是一次性的
alarm(2);

signal(SIGALRM, handle);

while (1);
return 0;
}

4、）siagction：  int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact)；

这个函数的参数很多，通过man我们还能看到函数内部还提供了一个结构体，不过，我们只需要利用其中的第一个数据就好，主要的使用方法如下：

#include <stdio.h>
#include <signal.h>

// 信号处理函数
void handle(int signum)
{
printf ("hello world\n");
alarm(2);
}

int main()
{
alarm(2);

struct sigaction act;
act.sa_handler = handle;
sigaction(SIGALRM, &act, NULL);

while (1);
return 0;
}