Dijkstra 提出的 P、V 原语,把互斥和同步压成一个整数加一张等待队列。课件给的值语义是:S>0 时表示可用资源个数,S=0 表示资源刚好用完且没人等,S<0 时 |S| 是等待队列里的进程数。教材里的信号量因此可以是负数。

Linux 的 System V 实现不这么记。semctl(GETVAL) 读到的值不会小于 0,上限是 32767;等资源的进程数记在 semncnt,等归零的进程数记在 semzcnt,上一次操作它的进程记在 sempid。三个计数器分开,账目比一个负数清楚,但和教材的符号约定对不上。按 S<0 去推 GETVAL 的结果会一直读错。

信号量是一个集合,不是一个整数

System V 的对象叫信号量集(semaphore set):一次 semget 建出 nsems 个信号量,每个有自己的值,用下标 semnum 区分,下标从 0 开始。单个信号量的模型是:

struct semaphore
{
    int value;             /* 还剩多少资源;负数表示有人在等 */
    pointer_PCB queue;     /* 等待队列 */
};

初值决定用途。初值写 1,P 一次拿一份、V 一次还一份,它是一把互斥锁;初值写 N,它表示最多 N 个执行流同时进入,是计数信号量。同一套 P/V 代码只改初始化数字,语义就换了。

semid_ds 和 ipc_perm 两个结构里,semid_ds 有 sem_perm、sem_otime(最后一次 semop 的时间)、sem_ctime(最后一次改动的时间)、sem_nsems(集合里信号量的个数);ipc_perm 有 __key、属主和创建者的 uid/gid、mode 权限位、__seq 序号。用户态拿到的 semid_ds 是内核结构的一份投影,semctl(IPC_STAT) 读的就是它。

P 和 V 的伪代码有两行不能照抄

P 原语的伪代码是:

P(s)
{
    s.value = s.value--;
    if (s.value < 0)
    {
        /* 进程置为等待态,PCB 挂到 s.queue 末尾 */
    }
}

第一行在 C 里是未定义行为。C11 6.5 第 2 段规定:一个标量对象在同一个表达式的两次求值之间被修改,行为未定义。s.value = s.value-- 既读又写同一个对象,gcc 在 -O2 下通常把它编成"值不变",也就是这一行根本没减。正确写法只有 --s.value; 或 s.value -= 1;。

V 的伪代码还有一处逻辑错误:

V(s)
{
    s.value = s.value++;
    if (s.value > 0)
    {
        /* 唤醒等待队列里的一个进程 */
    }
}

++ 同样要写成 ++s.value;。更关键的是判断方向反了。在这套"负值表示等待人数"的记账法里,V 把值加一之后,如果结果仍然小于等于 0,说明队列里至少还有一个人在等;结果大于 0 才表示没人等。所以条件应当是 if (s.value <= 0)。照课件写成 > 0,结果是有等待者时永远不唤醒,没人等的时候反而去队列里找一个。

if 和 while 的选择也取决于模型。这里的模型是"被唤醒就等于拿到资源",用 if 成立;如果实现改成"唤醒后重新竞争",醒来必须用 while 再检查一次,否则会丢唤醒。两套语义混着写,故障是偶发的。

semget 建集合,初值归 semctl

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

key 是全局命名空间里的名字,通常由 ftok(路径, 项目号) 生成;nsems 是集合里有几个信号量,不是初值;semflg 的低 9 位是权限,高位是 IPC_CREAT 和 IPC_EXCL。成功返回非负的 semid,失败返回 -1 并设置 errno。

集合已经存在时,nsems 和那 9 位权限都被忽略,只有 IPC_CREAT、IPC_EXCL 起作用。IPC_EXCL 单独用没有意义,它必须和 IPC_CREAT 一起,表示"不存在就建,存在就报 EEXIST"。这也意味着两段代码对同一个 key 用不同的 nsems,不会报错,后来者摸到的是别人的集合。

int semctl(int semid, int semnum, int cmd, ...);

第四个参数按 cmd 决定要不要传,类型是 union semun。《semctl(2)》写明这个联合体要调用者自己定义,glibc 的头文件默认不提供;打开 _GNU_SOURCE 时会带一份,自己再定义就会重复。

union semun
{
    int val;                 /* SETVAL */
    struct semid_ds *buf;    /* IPC_STAT, IPC_SET */
    unsigned short *array;   /* GETALL, SETALL */
    struct seminfo *__buf;   /* IPC_INFO,Linux 专有 */
};

返回值分两类。GETVAL 返回该信号量的当前值,GETPID 返回上次操作它的进程号,GETNCNT 返回等它变大的进程数,GETZCNT 返回等它归零的进程数;IPC_INFO 返回内核内部表里最高使用项的下标。其余命令成功时返回 0,失败统一返回 -1。IPC_RMID 会忽略 semnum,整个集合一起删。

初始化多个信号量时用 SETALL 一次写完,不要连着调两次 SETVAL。两次调用之间有一个窗口,别的进程能看到"这个能进、那个也能进"的中间态。

semop 的 sem_op 不只是 ±1

int semop(int semid, struct sembuf *sops, size_t nsops);
 
struct sembuf
{
    unsigned short sem_num;   /* 集合里的下标 */
    short          sem_op;    /* 加多少、减多少、还是等零 */
    short          sem_flg;   /* IPC_NOWAIT、SEM_UNDO */
};

sem_op 的语义按符号分三档:

  • 大于 0:给该信号量加这么多,相当于 V。
  • 小于 0:减这么多;减完如果小于 0,调用者阻塞,直到值够为止,相当于 P。-1 是拿一份,-3 是一次拿三份。
  • 等于 0:不改变值,等它变成 0 才返回,是屏障语义。

课件把 sem_op 注释成"-1 是 P,1 是 V",这只描述了二元信号量的用法。sem_flg 里 IPC_NOWAIT 让抢不到时立刻返回 EAGAIN,而不是睡在队列里;SEM_UNDO 让进程退出时由内核撤销它做过的操作,防止 kill -9 之后资源永久少掉。

nsops 允许一次传多个 sembuf,整组操作原子完成:要么全做,要么一个都不做。需要"给 A 减一、同时给 B 加一"这种成对动作时,这比两次 semop 安全。

下面的程序把三个接口串起来,父子进程用一把初值为 1 的信号量互斥输出:

/* gcc -std=c11 -Wall -o sem_demo sem_demo.c */
#define _XOPEN_SOURCE 700
 
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
 
union semun
{
    int val;
    struct semid_ds *buf;
    unsigned short *array;
    struct seminfo *__buf;
};
 
static void SemOp(int semid, short delta)
{
    struct sembuf sb;
 
    sb.sem_num = 0;
    sb.sem_op = delta;
    sb.sem_flg = SEM_UNDO;
 
    while (semop(semid, &sb, 1) == -1)
    {
        if (errno == EINTR)
            continue;
        perror("semop");
        exit(EXIT_FAILURE);
    }
}
 
int main(void)
{
    key_t key = ftok("/tmp", 0x77);
    if (key == -1)
    {
        perror("ftok");
        return EXIT_FAILURE;
    }
 
    int semid = semget(key, 1, IPC_CREAT | IPC_EXCL | 0660);
    if (semid == -1)
    {
        perror("semget");
        return EXIT_FAILURE;
    }
 
    union semun un;
    un.val = 1;
    if (semctl(semid, 0, SETVAL, un) == -1)
    {
        perror("semctl SETVAL");
        semctl(semid, 0, IPC_RMID);
        return EXIT_FAILURE;
    }
 
    pid_t pid = fork();
    if (pid == -1)
    {
        perror("fork");
        semctl(semid, 0, IPC_RMID);
        return EXIT_FAILURE;
    }
 
    int loops = pid == 0 ? 10 : 30;
    for (int i = 0; i < loops; i++)
    {
        SemOp(semid, -1);
        if (pid == 0)
            printf("C ");
        else
            printf("F ");
        fflush(stdout);
        SemOp(semid, 1);
    }
 
    if (pid == 0)
        _exit(0);
 
    waitpid(pid, NULL, 0);
    semctl(semid, 0, IPC_RMID);
    return 0;
}

semop 被信号打断时返回 -1、errno 为 EINTR,重试即可,别当成失败退出。课件里的 P()、V() 把返回值直接丢掉,EIDRM、EINVAL 都会被无声吞掉,这是后面析构提前删集合时最难查的地方。

建造者封装把"建集合"和"每次 PV"分成两层

课件用建造者模式(Builder)包了这套接口。它的调用顺序是固定的:

  1. SemaphoreBuilder 保存一个 _val,默认是 -1;SetVal(val) 只改这个数并返回 *this,所以能写成 sb.SetVal(1).Build(BUILD_SEM),忘了 SetVal 会在 Build 里被拦下。
  2. Build(flag) 先检查 _val 是否合法(小于 0 直接返回空指针),再 ftok(PATHNAME, PROJID) 拿 key,然后 semget(k, 1, flag) 建出只有一个信号量的集合。
  3. 只有 flag 恰好等于 BUILD_SEM 时才 semctl(semid, 0, SETVAL, un) 写初值。GET_SEM 走的是附着已有集合的路径,此时再 SETVAL 会把别人正在用的计数器重置。
  4. make_shared<Semaphore>(semid, flag) 把 semid 和 flag 一起交给产品对象。
  5. Semaphore 只负责三件事:P() 发 sem_op = -1,V() 发 sem_op = 1,析构时按 flag 决定要不要 IPC_RMID。

建造者模式的类图:Director 按步骤调用 buildPart,ConcreteBuilder 逐步组装,getResult 交出 Product。课件代码只用了 SetVal 加 Build 两步,是链式工厂的简化版

分层本身是合理的:初始化参数只进 Builder,运行期操作只进 Semaphore,两边通过 flag 传递"这次是不是新建"。问题也出在 flag 上。

GET_SEM 定义成裸的 IPC_CREAT,没带权限位。semget 的权限位只在新建时生效,所以谁先跑谁就把集合建成 mode 0000;之后属主自己 semop 也会拿到 EACCES。另一个进程再用 IPC_CREAT | IPC_EXCL 只会拿到 EEXIST。用 root 跑往往看不出问题,换普通用户就现形。

另一处是精确比较 if (BUILD_SEM == flag)。调用方改成 IPC_CREAT | IPC_EXCL | 0600,集合建出来了但初值没写,值保持 0,第一次 P 就阻塞。把"是否新建"做成独立的布尔参数,比比较宏的位组合可靠。

最要紧的是生命周期。Semaphore 的析构在父进程里调 IPC_RMID,而 fork 之后的子进程还在拿同一个 semid 做 P/V。IPC_RMID 一执行,集合立刻从内核表里消失,阻塞在上面的 semop 返回 EIDRM,之后再用这个 id 是 EINVAL。课件测试里父进程打 50 组、子进程打 10 组,多数时候子进程先结束;但只要父进程先跑完,子进程的 P 就会失败,而返回值被 (void)n 吃掉了,它于是没有持锁就进了临界区。

跨进程没有 RAII。析构函数只在触发它的那个进程里跑,它不知道另一个进程还在不在用。所有权应当显式:谁 Build(BUILD_SEM),谁在确认所有使用者退出后 IPC_RMID;只附着的进程用 GET_SEM,析构时什么都不做。

一把二元信号量只保证输出不被撕开

课件那段测试用初值 1 的信号量保护 printf("C") 与 printf("C ") 之间的间隔,以及父进程同样的 F。它验证的是互斥:一组字符不会被另一进程从中间插进去。它不保证顺序,F 和 C 谁先谁后仍然由调度决定。

要严格交替,需要两个信号量当话筒:sem[0] 是父进程的发言权、初值 1,sem[1] 是子进程的发言权、初值 0。父进程先 P(sem[0])、输出、再 V(sem[1]);子进程反过来。每次交接都要一次 P 一次 V,顺序自然被锁死。

两条清场命令:System V 信号量的生命周期随内核,进程退出不会自动删:

ipcs -s
ipcrm -s <semid>

程序昨天能跑、今天启动就 EACCES 或总是 EEXIST,先看这两个命令的输出里有没有上一轮的残留。

和 POSIX 信号量的差别

POSIX 信号量是另一套接口,值不会变成负数,也没有 SEM_UNDO:

System VPOSIX
对象key_t 加 semid,按集合管理sem_t *;命名用 sem_open("/name"),匿名用 sem_init 放在共享内存里
初值semctl(SETVAL/SETALL)sem_init 第三个参数,或 sem_open 第四个参数
加减semop 传 sembuf 数组,可一次原子操作多个sem_wait、sem_post 一次一个
抢不到阻塞,IPC_NOWAIT 返回 EAGAIN阻塞,sem_trywait 返回 EAGAIN
被信号打断EINTR,需重试sem_wait 返回 -1、errno 为 EINTR
进程退出撤销SEM_UNDO无
销毁IPC_RMID,立刻生效sem_unlink 摘掉名字,已有打开者继续用;匿名用 sem_destroy
生命周期随内核,重启前一直在命名信号量在 /dev/shm 里;sem_unlink 后等最后一个引用释放才消失,不 unlink 就一直留到重启

POSIX 的 sem_post 是 async-signal-safe 的,可以在信号处理函数里调用;sem_wait 不是,也不能在信号处理函数里等。System V 这一套则完全没有这个保证。要在信号处理函数里放行一个等待者,POSIX 接口更合适。

两套接口都能做互斥和同步。选 System V 的理由通常是"要和已有代码共用同一个 key、同一套 ipcs 运维习惯";新代码里用 POSIX 的更多,接口少、语义直,值也不会出现教材和实现两套记账法。