信号量（简介）
共享内存和消息队列，这两者都是用于交换数据，而信号量通常用来做进程同步。
在系统中，给予每一个进程一个信号量，代表每个进程目前的状态，未得到控制权的进程会在特定地方被强迫停下来，等待可以继续进行的信号到来。如果信号量是一个任意的整数，通常被称为计数信号量，或一般信号量；如果信号量只有二进制的0或1，称为二进制信号量。在linux系统中，二进制信号量又称互斥锁。
信号量（操作）
要掌握信号量，只要熟练掌握对信号量的请求和释放（归还）就行了，也就是 semop 函数，本质上它就是用来对信号量进行加或减的操作。当然，semctl 也很重要，它主要用来获取和设置 ipc 内核对象，另外它也可以获取和设置信号量的值。其中，信号量又存在着两种操作，分别为V操作与P操作，V操作会增加信号量 S的数值，P操作会减少它。
创建和获取信号量——semget()函数
函数 semget 主要是用来创建或获取信号量的 ipc 内核对象，同时返回其 id 号。
函数原型
int semget(key_t key, int nsems, int semflg);
参数key：整数值（唯一非零），不相关的进程可以通过它访问一个信号量，它代表程序可能要使用的某个资源，程序对所有信号量的访问都是间接的，程序先通过调用semget()函数并提供一个键，再由系统生成一个相应的信号标识符（semget()函数的返回值），只有semget()函数才直接使用信号量键，所有其他的信号量函数使用由semget()函数返回的信号量标识符。如果多个程序使用相同的key值，key将负责协调工作。
参数num_sems：指定需要的信号量数目，它的值几乎总是1。
参数sem_flags：是一组标志，当想要当信号量不存在时创建一个新的信号量，可以和值IPC_CREAT做按位或操作。设置了IPC_CREAT标志后，即使给出的键是一个已有信号量的键，也不会产生错误。而IPC_CREAT | IPC_EXCL则可以创建一个新的，唯一的信号量，如果信号量已存在，返回一个错误。
返回值：semget()函数成功返回一个相应信号标识符（非零），失败返回-1.
请求和释放信号量——semop()函数
它的作用是改变信号量的值，原型为：
int semop(int semid, struct sembuf *sops, unsigned nsops);
当请求的信号量值 > 0 时，semop 直接返回，否则会阻塞，直到信号量值大于 0。如果是释放（归还）资源，semop 直接返回。
该函数第二个参数是一个数组，第三个参数表示数组大小。第二个参数的结构体如下：
struct sembuf{
short sem_num; // 除非使用一组信号量，否则它为0
short sem_op; // 信号量在一次操作中需要改变的数据，通常是两个数，一个是-1，即P（等待）操作，
// 一个是+1，即V（发送信号）操作。
short sem_flg; // 通常为SEM_UNDO,使操作系统跟踪信号，
// 并在进程没有释放该信号量而终止时，操作系统释放信号量
};
em_num ： 操作第几个信号量
sem_op：为一个短整型，操作完成后，这个数值加到信号量上
sem_flg：可选项，一般为 0
IPC_NOWAIT：无论请求的资源有没有，立即返回。如果没有资源，errno 设置为 EAGAIN.
SEM_UNDO：如果设置该值，当进程结束后，该进程执行的所有的操作全部撤销。
请求资源（P 操作）
请求 3 个资源（将信号量值减 3）
struct sembuf op;
op.sem_num = 2; // 请求第2个资源（信号量）
op.sem_op = -3;
op.sem_flg = 0;
semop(id, &op, 1);
同时操作多个信号量
struct sembuf ops[3];
op[0].sem_num = 0; // 请求第 0 个资源（信号量）
op[0].sem_op = -1; // 申请 1 个资源
op[0].sem_flg = 0;
op[1].sem_num = 1; // 请求第 1 个资源（信号量）
op[1].sem_op = -5; // 申请 5 个资源
op[1].sem_flg = 0;
op[2].sem_num = 2; // 请求第 2 个资源（信号量）
op[2].sem_op = -3; // 申请 3 个资源
op[2].sem_flg = 0;
semop(id, ops, 3);
当然上面的写法是给新手看的，实际上可以这样写：
struct sembuf ops[3] = {
{0, -1, 0},
{1, -5, 0},
{2, -3, 0}
};
semop(id, ops, 3);
释放（归还）资源（V 操作）
释放 2 个资源（将信号量值加 2）
struct sembuf op;
op.sem_num = 1; // 请求第 1 个资源（信号量）
op.sem_op = 2;
op.sem_flg = 0;
semop(id, &op, 1);
同时操作多个信号量
struct sembuf ops[3] = {
{0, 4, 0}, // 释放 4 个 0 号资源
{1, 2, 0}, // 释放 2 个 1 号资源
{2, 5, 0} // 释放 5 个 2 号资源
};
semop(id, ops, 3);
实例
#include
#include
#include
#include
#include
#define R0 0
#define R1 1
#define R2 2
void printSem(int id) {
unsigned short vals[3] = { 0 };
semctl(id, 3, GETALL, vals);
printf("R0 = %d, R1= %d, R2 = %d\n\n", vals[0], vals[1], vals[2]);
}
int main() {
int id = semget(0x8888, 3, IPC_CREAT | IPC_EXCL | 0664);
// 打印信号量值
puts("信号量初始值（默认值）");
printSem(id);
// 1. 设置第 2 个信号量值
puts("1. 设置第 2 个信号量(R2)值为 20");
semctl(id, 2, SETVAL, 20);
printSem(id);
// 2. 同时设置 3 个信号量的值
puts("2. 同时设置 3 个信号量的值为 12, 5, 9");
unsigned short vals[3] = {12, 5, 9};
semctl(id, 0, SETALL, vals);
printSem(id);
// 3. 请求 2 个 R0 资源
puts("3. 请求 2 个 R0 资源");
struct sembuf op1 = {0, -2, 0};
semop(id, &op1, 1);
printSem(id);
// 4. 请求 3 个 R1 和 5 个 R2
puts("4. 请求 3 个 R1 和 5 个 R2");
struct sembuf ops1[2] = {
{1, -3, 0},
{2, -5, 0}
};
semop(id, ops1, 2);
printSem(id);
// 5. 释放 2 个 R1
puts("5. 释放 2 个 R1");
struct sembuf op2 = {1, 2, 0};
semop(id, &op2, 1);
printSem(id);
// 6. 释放 1 个 R0, 1 个 R1，3 个 R2
puts("6. 释放 1 个 R0, 1 个 R1，3 个 R2");
struct sembuf ops2[3] = {
{0, 1, 0},
{1, 1, 0},
{2, 3, 0}
};
semop(id, ops2, 3);
printSem(id);
// 7. 删除 ipc 内核对象
puts("7. 删除 ipc 内核对象");
semctl(id, 0, IPC_RMID);
return 0;
}
设置和获取信号量值——semctl()函数
该函数用来直接控制信号量信息，它的原型为：
int semctl(int sem_id, int sem_num, int command, ...);
如果有第四个参数，它通常是一个union semum结构，定义如下：
union semun {
int val;
struct semid_ds *buf;
unsigned short *arry;
};
前两个参数与前面一个函数中的一样，command通常是下面两个值中的其中一个
SETVAL：用来把信号量初始化为一个已知的值。p 这个值通过union semun中的val成员设置，其作用是在信号量第一次使用前对它进行设置。
IPC_RMID：用于删除一个已经无需继续使用的信号量标识符。
设置值
设置第2个信号量的值为 5
semctl(id, 2, SETVAL, 5);
设置所有信号量的值
// 将 3 个信号量的值分别设置为 3， 6， 9
unsigned short vals[3] = {3, 6, 9};
// 注意：这时候第二个参数被忽略
semctl(id, 0, SETALL, vals);
获取值
获取第 1 个信号量的值
// 注意这时候第 4 个参数就不用写了，获取的值通过返回值返回
int val = semctl(id, 1, GETVAL);
获取所有信号量的值
unsigned short vals[3];
// 这时候第二个参数被忽略，获取的值保存到 vals 数组
semctl(id, 0, GETALL, vals);
信号量（生产者与消费者模型）
PV 原语
P(S) ：表示将资源 S 数量减 1，即 S = S - 1. 如果 S <= 0，该进程进入等待。
V(S)：表示将资源 S 数量加 1，即 S = S + 1. 如果 S > 0，该进程继续执行，否则释放一个正在等待的进程。
PV 操作是原子的，原子操作可以理解为一次性执行完若干条机器指令，中间不能打断。如果一个操作不是原子的，就可能会产生竞态错误。
生产者与消费者模型
问题描述假设有一个缓冲区，该缓冲区最多只能存放 5 个蛋糕。有若干生产者(producer)，每个生产者一次生产一个蛋糕，如果发现缓冲区有空位，就将蛋糕放进去。另外还有若干消费者(consumer)，每个消费者如果发现缓冲区有蛋糕，就拿走一个蛋糕。
初步解决
要完成这个功能，直观上我们会写出下面的代码：
生产者进程
while(1) {
// 为了方便演示，这里只用另一个共享内存中的变量来统计缓冲区中蛋糕的个数。
if (cake < 5) {
cake++;
}
}
消费者进程
while(1) {
if (cake > 0) {
cake--;
}
}
如果程序真的就这样写，会有什么问题？
假设某个时刻 cake == 1,有一个消费者进程 C1 执行到 if (cake > 0)进入 if 语句块后，进程由于时间片耗尽被切到到另一个消费者进程 C2，此时 cake 仍然等于 1，C2 同样也进入了 if 语句块。此时面临的问题是，C1 和 C2 都拿走一块蛋糕，结果 cake 被减 2 次，变成了 -1. 这种情况是不允许出现的。
改进版本一
这里的 cake 明显是竞争资源，在任意一个时刻，只能有一个进程去操作它。上面的代码可以改进为：
生产者进程
while(1) {
P(MUTEX);
if (cake < 5) {
cake++;
}
V(MUTEX);
}
消费者进程
while(1) {
P(MUTEX);
if (cake > 0) {
cake--;
}
V(MUTEX);
}
上面改进的代码里引入了信号量 MUTEX，用来表示资源 cake 是否被占用，MUTEX 的初始值为 1. 上面的程序就可以达到对 cake 互斥访问的目的了。
但问题还没有结束，假如说蛋糕数为 0 了，操作系统仍然会调度消费者进程！那么问题来了，消费者进程还有必要调度？这不是对 CPU 的浪费吗？假如只有一个两个消费者进程还好说，如果有几十个，上百个这样的进程呢？
改进版本二
我们希望做到，如果蛋糕数为 0，消费者进程就去睡觉吧！别再被操作系统调度了，什么时候有蛋糕了，再唤醒它们！
这里再次引入信号量 FULL 和 EMPTY。FULL 表示蛋糕的个数，初始值为 0. EMPTY 表示空缓冲区的个数，初始值为 5.
改进前面的程序：
生产者进程
while(1) {
P(EMPTY); // 减少一个空缓冲区个数
P(MUTEX);
if (cake < 5) {
cake++;
}
V(MUTEX);
V(FULL); // 增加一个蛋糕个数
}
消费者进程
while(1) {
P(FULL); // 减少一个蛋糕个数
P(MUTEX);
if (cake > 0) {
cake--;
}
V(MUTEX);
V(EMPTY); // 增加一个空缓冲区个数
}
如果用来描述蛋糕个数的信号量 FULL <= 0 了，消费者执行到 P(FULL) 就会立即被投入等待状态，不再被 OS 调度。什么时候 FULL > 0 了，才可能会被 OS 调度。
信号量的生产者和消费者模式实现
生产者消费者写在一套代码里，运行的时候依参数来控制具体是运行生产者还是消费者。说明如下：
./pc -b : 初始化 ipc 内核对象
./pc -d : 删除 ipc 内核对象
./pc -p : 启动生产者进程
./pc -c : 启动消费者进程
#include
#include
#include
#include
#include
#define MUTEX 0
#define FULL 1
#define EMPTY 2
/*
* Create
* 创建和获取信号量 ipc 内核对象 id
* count > 0 表示创建，count = 0 表示获取
*/
int C(int count) {
int id;
if (count > 0){
id = semget(0x8888, count, IPC_CREAT | IPC_EXCL | 0664);
}
else{
id = semget(0x8888, 0, 0);
}
return id;
}
/*
* Set
* 初始化第 semnum 个信号量的值为 val
*/
void S(int id, int semnum, int val) {
semctl(id, semnum, SETVAL, val);
}
/*
* Delete
* 删除信号量内核对象
*/
void D(int id) {
semctl(id, 0, IPC_RMID);
}
/*
* 请求第 semnum 个信号量，将其值减 1
*/
void P(int id, int semnum) {
struct sembuf op;
op.sem_num = semnum;
op.sem_op = -1;
op.sem_flg = 0;
semop(id, &op, 1);
}
/*
* 归还第 semnum 个信号量，将其值加 1
*/
void V(int id, int semnum) {
struct sembuf op;
op.sem_num = semnum;
op.sem_op = 1;
op.sem_flg = 0;
semop(id, &op, 1);
}
/*
* Get
* 获取第 semnum 个信号量的值
*/
int G(int id, int semnum) {
return semctl(id, semnum, GETVAL);
}
static void init() {
int id = C(3);
S(id, MUTEX, 1);
S(id, FULL, 0);
S(id, EMPTY, 5);
int shmid = shmget(0x8888, 4, IPC_CREAT | IPC_EXCL | 0664);
int *cake= shmat(shmid, NULL, 0);
*cake = 0;
shmdt(cake);
}
static int getsemid() {
return C(0);
}
static int getshmid() {
int id = shmget(0x8888, 0, 0);
return id;
}
static void release(int id) {
D(id);
shmctl(getshmid(), IPC_RMID, NULL);
}
static void producer() {
int id = getsemid();
int shmid = getshmid();
int *cake = shmat(shmid, NULL, 0);
while(1) {
P(id, EMPTY);
P(id, MUTEX);
printf("current cake = %d, ", *cake);
(*cake)++;
printf("produce a cake, ");
printf("cake = %d\n", *cake);
V(id, MUTEX);
V(id, FULL);
sleep(1);
}
shmdt(cake);
}
static void consumer() {
int id = getsemid();
int shmid = getshmid();
int *cake = shmat(shmid, NULL, 0);
int count = 10;
while(count--) {
P(id, FULL);
P(id, MUTEX);
printf("current cake = %d, ", *cake);
(*cake)--;
printf("consume a cake, ");
printf("cake = %d\n", *cake);
V(id, MUTEX);
V(id, EMPTY);
}
shmdt(cake);
}
int main(int argc, char *argv[]) {
if (argc < 2) {
printf("usage: %s 