信号量 代码来自：嵌入式linux应用开发标准教程 信号量 http://www.cnblogs.com/hjslovewcl/archive/2011/03/03/2314341.html

当我们在多用户系统，多进程系统，或是两者混合的系统中使用线程操作编写程序时，我们经常会发现我们有段临界代码，在此处我们需要保证一个进程（或是一个线程的执行）需要排他的访问一个资源。
信号量有一个复杂的编程接口。幸运的是，我们可以很容易的为自己提供一个对于大多数的信号量编程问题足够高效的简化接口。
为了阻止多个程序同时访问一个共享资源所引起的问题，我们需要一种方法生成并且使用一个标记从而保证在临界区部分一次只有一个线程执行。线程相关的方法，我们可以使用互斥或信号量来控制一个多线程程序对于临界区的访问。
编写通用目的的代码保证一个程序排他的访问一个特定的资源是十分困难的，尽管有一个名为Dekker的算法解决方法。不幸的是，这个算法依赖于"忙等待" 或是"自旋锁"，即一个进程的连续运行需要等待一个内存地址发生改变。在一个多任务环境中，例如Linux，这是对CPU资源的无谓浪费。如果硬件支持， 这样的情况就要容易得多，通常以特定CPU指令的形式来支持排他访问。硬件支持的例子可以是访问指令与原子方式增加寄存器值，从而在读取/增加/写入的操 作之间就不会有其他的指令运行。

我们已经了解到的一个要行的解决方法就是使用O_EXCL标记调用open函数来创建文件，这提供了原子方式的文件创建。这会使得一个进程成功的获得一个标记：新创建的文件。这个方法可以用于简单的问题，但是对于复杂的情况就要显得烦琐与低效了。

当Dijkstr引入信号量的概念以后，并行编程领域前进了一大步。正如我们在第12章所讨论的，信号量是一个特殊的变量，他是一个整数，并且只有两个操 作可以使得其值增加：等待(wait)与信号(signal)。因为在Linux与UNIX编程中，"wait"与"signal"已经具有特殊的意义 了，我们将使用原始概念：
用于等待(wait)的P(信号量变量)
用于信号(signal)的V(信号量变量)

这两字母来自等待(passeren：通过，如同临界区前的检测点)与信号(vrjgeven：指定或释放，如同释放临界区的控制权)的荷兰语。有时我们也会遇到与信号量相关的术语"up"与"down"，来自于信号标记的使用。

信号量定义 

最简单的信号量是一个只有0与1两个值的变量，二值信号量。这是最为通常的形式。具有多个正数值的信号量被称之为通用信号量。在本章的其余部分，我们将会讨论二值信号量。

P与V的定义出奇的简单。假定我们有一个信号量变量sv，两个操作定义如下：

P(sv)    如果sv大于0，减小sv。如果sv为0，挂起这个进程的执行。                       P就是排队去等待用这个资源
V(sv)    如果有进程被挂起等待sv，使其恢复执行。如果没有进行被挂起等待sv，增加sv。V就是企图释放这个共享资源

信号量的另一个理解方式就是当临界区可用时信号量变量sv为true，当临界区忙时信号量变量被P(sv)减小，从而变为false，当临界区再次可用时 被V(sv)增加。注意，简单的具有一个我们可以减小或是增加的通常变量并不足够，因为我们不能用C，C++或是其他的编程语言来表述生成信号，进行原子 测试来确定变量是否为true，如果是则将其变为false。这就是使得信号量操作特殊的地方。

一个理论例子 

我们可以使用一个简单的理论例子来了解一下信号量是如何工作的。假设我们有两个进程proc1与proc2，这两个进程会在他们执行的某一时刻排他的访问 一个数据库。我们定义一个单一的二值信号量，sv，其初始值为1并且可以为两个进程所访问。两个进程然后需要执行同样的处理来访问临界区代码；实际上，这 两个进程可以是同一个程序的不同调用。

这两个进程共享sv信号量变量。一旦一个进程已经执行P(sv)操作，这个进程就可以获得信号量并且进入临界区。第二个进程就会被阻止进行临界区，因为当他尝试执行P(sv)时，他就会等待，直到第一个进程离开临界区并且执行V(sv)操作来释放信号量。

所需要的过程如下：

semaphore sv = 1;
loop forever {
    P(sv);
    critical code section;
    V(sv);
    noncritical code section;
}

这段代码出奇的简单，因为P操作与V操作是十分强大的。图14-1显示了P操作与V操作如何成为进行临界区代码的门槛。

Linux信号量工具 

现在我们已经了解了什么是信号量以及他们在理论上是如何工作的，现在我们可以来了解一下这些特性在Linux中是如何实现的。信号量函数接口设计十分精 细，并且提供了比通常所需要的更多的实用性能。所有的Linux信号量函数在通用的信号量数组上进行操作，而不是在一个单一的二值信号量上进行操作。乍看 起来，这似乎使得事情变得更为复杂，但是在一个进程需要锁住多个资源的复杂情况下，在信号量数组上进行操作将是一个极大的优点。在这一章，我们将会关注于 使用单一信号量，因为在大多数情况下，这正是我们需要使用的。

信号量函数定义如下：

#include
int semctl(int sem_id, int sem_num, int command, ...);
int semget(key_t key, int num_sems, int sem_flags);
int semop(int sem_id, struct sembuf *sem_ops, size_t num_sem_ops);

事实上，为了获得我们特定操作所需要的#define定义，我们需要在包含sys/sem.h文件之前通常需要包含sys/types.h与sys/ipc.h文件。而在某些情况下，这并不是必须的。

因为我们会依次了解每一个函数，记住，这些函数的设计是用于操作信号量值数组的，从而会使用其操作向比单个信号量所需要的操作更为复杂。

注意，key的作用类似于一个文件名，因为他表示程序也许会使用或是合作所用的资源。相类似的，由semget所返回的并且为其他的共享内存函数所用的标 识符与由fopen函数所返回 的FILE *十分相似，因为他被进程用来访问共享文件。而且与文件类似，不同的进程会有不同的信号量标识符，尽管他们指向相同的信号量。key与标识符的用法对于在 这里所讨论的所有IPC程序都是通用的，尽管每一个程序会使用独立的key与标识符。

semget 

semget函数创建一个新的信号量或是获得一个已存在的信号量键值。

int semget(key_t key, int num_sems, int sem_flags);

第一个参数key是一个用来允许不相关的进程访问相同信号量的整数值。所有的信号量是为不同的程序通过提供一个key来间接访问的，对于每一个信号量系统 生成一个信号量标识符。信号量键值只可以由semget获得，所有其他的信号量函数所用的信号量标识符都是由semget所返回的。

还有一个特殊的信号量key值，IPC_PRIVATE(通常为0)，其作用是创建一个只有创建进程可以访问的信号量。这通常并没有有用的目的，而幸运的是，因为在某些Linux系统上，手册页将IPC_PRIVATE并没有阻止其他的进程访问信号量作为一个bug列出。

num_sems参数是所需要的信号量数目。这个值通常总是1。

sem_flags参数是一个标记集合，与open函数的标记十分类似。低九位是信号的权限，其作用与文件权限类似。另外，这些标记可以与 IPC_CREAT进行或操作来创建新的信号量。设置IPC_CREAT标记并且指定一个已经存在的信号量键值并不是一个错误。如果不需 要，IPC_CREAT标记只是被简单的忽略。我们可以使用IPC_CREAT与IPC_EXCL的组合来保证我们可以获得一个新的，唯一的信号量。如果 这个信号量已经存在，则会返回一个错误。

如果成功，semget函数会返回一个正数；这是用于其他信号量函数的标识符。如果失败，则会返回-1。

semop 

函数semop用来改变信号量的值：

int semop(int sem_id, struct sembuf *sem_ops, size_t num_sem_ops);

第一个参数，sem_id，是由semget函数所返回的信号量标识符。第二个参数，sem_ops，是一个指向结构数组的指针，其中的每一个结构至少包含下列成员：

struct sembuf {
    short sem_num;
    short sem_op;
    short sem_flg;
}

第一个成员，sem_num，是信号量数目，通常为0，除非我们正在使用一个信号量数组。sem_op成员是信号量的变化量值。（我们可以以任何量改变信 号量值，而不只是1）通常情况下中使用两个值，-1是我们的P操作，用来等待一个信号量变得可用，而+1是我们的V操作，用来通知一个信号量可用。

最后一个成员，sem_flg，通常设置为SEM_UNDO。这会使得操作系统跟踪当前进程对信号量所做的改变，而且如果进程终止而没有释放这个信号量， 如果信号量为这个进程所占有，这个标记可以使得操作系统自动释放这个信号量。将sem_flg设置为SEM_UNDO是一个好习惯，除非我们需要不同的行 为。如果我们确实变我们需要一个不同的值而不是SEM_UNDO，一致性是十分重要的，否则我们就会变得十分迷惑，当我们的进程退出时，内核是否会尝试清 理我们的信号量。

semop的所用动作会同时作用，从而避免多个信号量的使用所引起的竞争条件。我们可以在手册页中了解关于semop处理更为详细的信息。

semctl 

semctl函数允许信号量信息的直接控制：

int semctl(int sem_id, int sem_num, int command, ...);

第一个参数，sem_id，是由semget所获得的信号量标识符。sem_num参数是信号量数目。当我们使用信号量数组时会用到这个参数。通常，如果 这是第一个且是唯一的一个信号量，这个值为0。command参数是要执行的动作，而如果提供了额外的参数，则是union semun，根据X/OPEN规范，这个参数至少包括下列参数：

union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
}

许多版本的Linux在头文件(通常为sem.h)中定义了semun联合，尽管X/Open确认说我们必须定义我们自己的联合。如果我们发现我们确实需 要定义我们自己的联合，我们可以查看semctl手册页了解定义。如果有这样的情况，建议使用手册页中提供的定义，尽管这个定义与上面的有区别。

有多个不同的command值可以用于semctl。在这里我们描述两个会经常用到的值。要了解semctl功能的详细信息，我们应该查看手册页。

这两个通常的command值为：

SETVAL：用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。
IPC_RMID：当信号量不再需要时用于删除一个信号量标识。

semctl函数依据command参数会返回不同的值。对于SETVAL与IPC_RMID，如果成功则会返回0，否则会返回-1。

使用信号量 

正如我们在前面部分的描述中所看到的，信号量操作是相当复杂的。这是最不幸的，因为使用临界区进行多进程或是多线程编程是一个十分困难的问题，而其拥有其自己复杂的编程接口也增加了编程负担。

幸运的是，我们可以使用最简单的二值信号量来解决大多数需要信号量的问题。在我们的例子中，我们会使用所有的编程接口来创建一个非常简单的用于二值信号量的P
与V类型接口。然后，我们会使用这个简单的接口来演示信号量如何工作。

要试验信号量，我们将会使用一个简单的程序，sem1.c，这个程序我们可以多次调用。我们将会使用一个可选的参数来标识这个程序是负责创建信号量还是销毁信号量。

我们使用两个不同字符的输出来标识进入与离开临界区。使用参数调用的程序会在进入与离开其临界区时输出一个X，而另一个程序调用会在进入与离开其临界区时输出一个O。因为在任何指定的时间内只有一个进程能够进入其临界区，所以所有X与O字符都是成对出现的



实例：父进程创建一个子进程，资源默认是被占用的只要子进程不释放资源，父进程就一直等待使用资源 /* sem_com.h */ #ifndef SEM_COM_H #define SEM_COM_H #include #include union semun { int val; struct semid_ds *buf; unsigned short *array; }; int init_sem(int, int); int del_sem(int); int sem_p(int); int sem_v(int); #endif /* SEM_COM_H */
/* sem_com.c */ #include "sem_com.h" int init_sem(int sem_id, int init_value) { union semun sem_union; sem_union.val = init_value; if (semctl(sem_id, 0, SETVAL, sem_union) == -1) { perror("Initialize semaphore"); return -1; } return 0; } int del_sem(int sem_id) { union semun sem_union; if (semctl(sem_id, 0, IPC_RMID, sem_union) == -1) { perror("Delete semaphore"); return -1; } } int sem_p(int sem_id) { struct sembuf sem_b; sem_b.sem_num = 0; /*id*/ sem_b.sem_op = -1; /* P operation*/ sem_b.sem_flg = SEM_UNDO; if (semop(sem_id, &sem_b, 1) == -1) { perror("P operation"); return -1; } return 0; } int sem_v(int sem_id) { struct sembuf sem_b; sem_b.sem_num = 0; /* id */ sem_b.sem_op = 1; /* V operation */ sem_b.sem_flg = SEM_UNDO; if (semop(sem_id, &sem_b, 1) == -1) { perror("V operation"); return -1; } return 0; }
应用 /* fork.c */ #include #include #include #include #include #include #include #define DELAY_TIME 3 int main(void) { pid_t result; int sem_id; sem_id = semget(ftok(".", 'a'), 1, 0666|IPC_CREAT); /* 创建一个信号量*/ init_sem(sem_id, 0); //初始值设为0资源被占用 /*调用fork函数，其返回值为result*/ result = fork(); /*通过result的值来判断fork函数的返回情况，首先进行出错处理*/ if(result == -1) { perror("Fork "); } else if (result == 0) /*返回值为0代表子进程*/ { printf("Child process will wait for some seconds... "); sleep(DELAY_TIME); printf("The returned value is %d in the child process(PID = %d) ", result, getpid()); sem_v(sem_id); //释放资源 } else /*返回值大于0代表父进程*/ { sem_p(sem_id); //等待资源，如果子进程不释放 就一直等 printf("The returned value is %d in the father process(PID = %d) ", result, getpid()); sem_v(sem_id); //释放资源 del_sem(sem_id); //删除信号量 } exit(0); }



实例2 服务器 #include #include #define SEGSIZE 1024 #define READTIME 1 union semun { int val; struct semid_ds *buf; unsigned short *array; } arg; //生成信号量 int sem_creat(key_t key) { union semun sem; int semid; sem.val = 0; semid = semget(key,1,IPC_CREAT|0666); if (-1 == semid){ printf("create semaphore error "); exit(-1); } semctl(semid,0,SETVAL,sem); return semid; } //删除信号量 void del_sem(int semid) { union semun sem; sem.val = 0; semctl(semid,0,IPC_RMID,sem); } //p int p(int semid) { struct sembuf sops={0,+1,IPC_NOWAIT}; return (semop(semid,&sops,1)); } //v int v(int semid) { struct sembuf sops={0,-1,IPC_NOWAIT}; return (semop(semid,&sops,1)); } int main() { key_t key; int shmid,semid; char *shm; char msg[7] = "-data-"; char i; struct semid_ds buf; key = ftok("/",0); shmid = shmget(key,SEGSIZE,IPC_CREAT|0604); if (-1 == shmid){ printf(" create shared memory error "); return -1; } shm = (char *)shmat(shmid,0,0); if (-1 == (int)shm){ printf(" attach shared memory error "); return -1; } semid = sem_creat(key); for (i = 0;i <= 3;i++){ sleep(1); p(semid); sleep(READTIME); msg[5] = '0' + i; memcpy(shm,msg,sizeof(msg)); sleep(58); v(semid); } shmdt(shm); shmctl(shmid,IPC_RMID,&buf); del_sem(semid); return 0; //gcc -o shm shm.c -g } 2.2 客户端 #include #include #include #define SEGSIZE 1024 #define READTIME 1 union semun { int val; struct semid_ds *buf; unsigned short *array; } arg; // 打印程序执行时间 void out_time(void) { static long start = 0; time_t tm; if (0 == start){ tm = time(NULL); start = (long)tm; printf(" now start ... "); } printf(" second: %ld ",(long)(time(NULL)) - start); } //创建信号量 int new_sem(key_t key) { union semun sem; int semid; sem.val = 0; semid = semget(key,0,0); if (-1 == semid){ printf("create semaphore error "); exit(-1); } return semid; } //等待信号量变成0 void wait_v(int semid) { struct sembuf sops={0,0,0}; semop(semid,&sops,1); } int main(void) { key_t key; int shmid,semid; char *shm; char msg[100]; char i; key = ftok("/",0); shmid = shmget(key,SEGSIZE,0); if(-1 == shmid){ printf(" create shared memory error "); return -1; } shm = (char *)shmat(shmid,0,0); if (-1 == (int)shm){ printf(" attach shared memory error "); return -1; } semid = new_sem(key); for (i = 0;i < 3;i ++){ sleep(2); wait_v(semid); printf("Message geted is: %s ",shm + 1); out_time(); } shmdt(shm); return 0; // gcc -o shmc shmC.c -g }