进程之间默认互相看不见。每个进程有自己的地址空间,一个进程里的变量地址拿到另一个进程里毫无意义。想通信只能借助内核或共同的文件——内核提供一块两边都能访问的东西,或者提供一根把数据从 A 搬到 B 的管。这就是 IPC(Inter-Process Communication)的全部出发点。

用途按需求分四类:传数据、共享资源、通知事件(比如子进程终止时告诉父进程)、控制另一个进程的执行(调试器拦截被调试进程的异常)。实现方式经历三代:管道、System V IPC、POSIX IPC。

家族成员
管道匿名管道 pipe、命名管道 FIFO
System V IPC消息队列、共享内存、信号量
POSIX IPC消息队列、共享内存、信号量、互斥量、条件变量、读写锁

System V 那三个是老三样,接口 xxxget/xxxctl 风格,生命周期跟着内核;POSIX 那一套更贴近文件语义和线程语义,多出来的互斥量、条件变量、读写锁本来就是给多线程用的。

匿名管道:一根管子的两个端

#include <unistd.h>
 
int pipe(int fd[2]);

成功返回 0,失败返回 -1 并设置 errno。fd[0] 是读端,fd[1] 是写端。写进去的数据从 fd[1] 进,从 fd[0] 出,反过来不行。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
int main(void)
{
    int fds[2];
    char buf[100];
    ssize_t n;
 
    if (pipe(fds) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
 
    while (fgets(buf, sizeof(buf), stdin) != NULL) {
        n = (ssize_t)strlen(buf);
        if (write(fds[1], buf, (size_t)n) != n) {
            perror("write to pipe");
            break;
        }
        memset(buf, 0, sizeof(buf));
        if ((n = read(fds[0], buf, sizeof(buf))) == -1) {
            perror("read from pipe");
            break;
        }
        if (write(STDOUT_FILENO, buf, (size_t)n) != n) {
            perror("write to stdout");
            break;
        }
    }
    return 0;
}

这段程序自己跟自己通信:终端输入进管道,再从管道读出来打到屏幕。管道容量有限,写满之后写端会阻塞,所以"先写一大段再读"的顺序不能随便改。

pipe 返回的两个 fd 不是两根管子,是同一根管子的两端。fork 之后子进程复制了 fd 表,父子各持有一份读写端:

上半:父进程 fd 表里 fd[0]、fd[1] 分别指向管道的读端和写端。中段:fork 之后子进程拿到同样两个 fd,父子共用这根管道。下半:父关 fd[0]、子关 fd[1] 之后,剩下单向的数据流

这也是"匿名管道只能用于有亲缘关系的进程"的真正原因:没有血缘的进程拿不到这个已经打开的 struct file。

从内核看,管道没有独立的数据结构,它借用文件系统的 inode。两个 struct file(一个读一个写)指向同一个 inode,inode 里记着缓冲区,实际数据放在一个数据页上:

进程 1 和进程 2 各自的 file 结构都指向同一个 inode,inode 再指向同一个数据页;写操作和读操作作用在这同一块页上

所以管道的用法和文件完全一致,read/write/close 都通用。Linux 的"一切皆文件"在这里体现得最直接。

管道的五条行为规则

读空与写满。默认(未设 O_NONBLOCK)时,管道没数据 read 阻塞,管道满 write 阻塞;设了 O_NONBLOCK,两种情况都立即返回 -1,errno 为 EAGAIN。

EOF。所有写端的 fd 都关闭之后,read 返回 0,而不是阻塞。判断依据是"还有没有别的副本",不是"我这一侧关没关"。这解释了进程池退出时最常见的卡死:父进程给工人 1 建了管道 A,fork 工人 2 时把 A 的写端也继承了过去;父进程后来关掉自己那份,A 仍有一个看不见的写者,工人 1 就永远等不到 EOF。

读端全关之后写。所有读端关闭后继续 write,内核给写进程发 SIGPIPE,默认动作是终止进程。

原子性。写入量不超过 PIPE_BUF 时,内核保证这次写是一个不可分割的整体,多个进程同时写不会交错;超过 PIPE_BUF 就不再保证。Linux 上 PIPE_BUF 是 4096 字节,与 4 KB 页对齐。默认管道容量是 64 KB,即 16 页。

半双工。数据只能单向流动,双向通信要两根管子:

进程 A 与进程 B 之间摆两根管道,管道 1 走 A→B,管道 2 走 B→A,两根合起来才是双向通信

另外两条性质:管道提供流式服务,不保留消息边界,读到的字节数取决于调用时给多大缓冲;管道的生命周期随进程,所有持有它的进程都退出后内核释放,不需要显式删除。

用管道搭一个最小进程池

进程池的结构是"一个 master + N 个 worker + N 根管道"。master 给每个 worker 建一根管道,worker 的读端 dup2 到 0 号 fd,这样 worker 只管从标准输入读,不关心管道细节。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
 
#define NWORKER 3
 
static void worker(int idx, int rfd)
{
    int cmd;
    ssize_t n;
 
    while ((n = read(rfd, &cmd, sizeof(cmd))) > 0) {
        printf("worker %d (pid %d) got task %d\n", idx, getpid(), cmd);
        fflush(stdout);
    }
    printf("worker %d quit\n", idx);
}
 
int main(void)
{
    int wfd[NWORKER];
    pid_t pid[NWORKER];
    int i, task;
 
    for (i = 0; i < NWORKER; i++) {
        int p[2];
        if (pipe(p) == -1) {
            perror("pipe");
            return 1;
        }
        if ((pid[i] = fork()) == 0) {
            close(p[1]);
            int j;
            for (j = 0; j < i; j++)      /* 关掉继承来的其他管道写端 */
                close(wfd[j]);
            worker(i, p[0]);
            close(p[0]);
            _exit(0);
        }
        close(p[0]);
        wfd[i] = p[1];
    }
 
    for (task = 0; task < 9; task++) {
        write(wfd[task % NWORKER], &task, sizeof(task));
        usleep(200000);
    }
 
    for (i = 0; i < NWORKER; i++)
        close(wfd[i]);                    /* 关写端,worker 才会读到 EOF */
 
    for (i = 0; i < NWORKER; i++)
        waitpid(pid[i], NULL, 0);
 
    return 0;
}

编译 gcc pool.c -o pool。两个细节值得单独看。

第一,子进程里的 for (j = 0; j < i; j++) close(wfd[j])。如果漏了,第 i 个 worker 会继承前 i 根管道的写端,它们的 EOF 永远等不到。

第二,父进程先统一 close 所有写端,再统一 waitpid。写成"关一根、等一个"会让第二个 worker 等不到退出,因为它的写端还开着;逐个关、逐个等,顺序反了同样会卡。这两条在课件的进程池里也是同一套逻辑,CloseProcessPool 之所以把 close 和 wait 分成两轮,原因就在这里。

命名管道:有名字,所以没有血缘限制

匿名管道的限制只有一条:必须是亲戚。要给不相关的进程用,就让管道在文件系统里有个名字,这个特殊文件叫 FIFO,也常叫命名管道。

mkfifo mypipe          # 命令行
int mkfifo(const char *filename, mode_t mode);

mkfifo("tp", 0644) 创建一个叫 tp 的文件,ls -l 看它类型是 p,大小 0。读写用 open,打开之后语义与匿名管道完全一样。唯一的差别在创建和打开的方式:

  • 匿名管道由 pipe 一次性创建并打开;
  • 命名管道由 mkfifo 创建,再由 open 打开。

打开规则比匿名管道多一层,因为两端是独立进程,可能只有一个到了:

打开方式阻塞(默认)O_NONBLOCK
只读打开阻塞到有进程以写打开该 FIFO立即返回成功
只写打开阻塞到有进程以读打开该 FIFO立即失败,errno = ENXIO

用两个独立进程做一次文件拷贝就能体会:

/* write_side.c:读普通文件,写进 FIFO */
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
 
int main(void)
{
    char buf[1024];
    ssize_t n;
    int infd = open("abc", O_RDONLY);
    int outfd = open("tp", O_WRONLY);      /* 阻塞,直到有人读打开 tp */
 
    if (infd < 0 || outfd < 0) { perror("open"); return 1; }
    while ((n = read(infd, buf, sizeof(buf))) > 0)
        write(outfd, buf, (size_t)n);
    close(infd);
    close(outfd);
    return 0;
}
/* read_side.c:从 FIFO 读,写进目标文件,最后删掉 FIFO */
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
 
int main(void)
{
    char buf[1024];
    ssize_t n;
    int outfd = open("abc.bak", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    int infd = open("tp", O_RDONLY);
 
    if (infd < 0 || outfd < 0) { perror("open"); return 1; }
    while ((n = read(infd, buf, sizeof(buf))) > 0)
        write(outfd, buf, (size_t)n);
    close(infd);
    close(outfd);
    unlink("tp");
    return 0;
}

两个程序各自 open,一端阻塞等另一端,一旦对上就变成普通数据流。FIFO 退出时不自动消失,unlink 要有人负责。

共享内存:最快,也最没规矩

管道每一次读写都要经过内核:数据从 A 的用户空间拷进内核缓冲,再从内核缓冲拷到 B 的用户空间。共享内存把这个环节全砍掉——内核把同一块物理页映射进两个进程的地址空间,两边直接读写同一块内存,不产生系统调用。

进程 A 和进程 B 的地址空间各自展开,中间那层标着"共享内存、内存映射和共享库位于此处"的区域,就是两个地址空间里同一块物理页的两个映射

四个接口:

int   shmget(key_t key, size_t size, int shmflg);
void *shmat(int shmid, const void *shmaddr, int shmflg);
int   shmdt(const void *shmaddr);
int   shmctl(int shmid, int cmd, struct shmid_ds *buf);

shmget 的 shmflg 有两种组合:只给 IPC_CREAT,不存在就创建、存在就返回已有的;给 IPC_CREAT | IPC_EXCL,不存在才创建,已存在就报错。后者用来保证"我是创建者",创建者负责最终销毁。size 按页向上取整。

key 通常由 ftok(path, proj_id) 生成:把一个存在的路径和一个小整数揉成一个 key_t,两个进程只要用同一对参数就能得到同一个 key。

shmat 的 shmaddr 有四种语义:

  • 传 NULL,由内核选一个合适的地址,这是常规做法;
  • 非 NULL 且没开 SHM_RND,就以 shmaddr 为起始地址;
  • 非 NULL 且开了 SHM_RND,地址向下对齐到 SHMLBA 的整数倍,算法是 shmaddr - (shmaddr % SHMLBA);
  • shmflg 带 SHM_RDONLY,挂接只读。

shmdt 做的是"脱离",不是"删除"。共享内存段仍然留在内核里,别的进程还能挂上来。真正删除要用 shmctl(shmid, IPC_RMID, NULL),即使还有进程挂着,删除标记也会生效,最后一个脱离时才真正回收。

一个完整的创建与使用流程:

#include <stdio.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
 
#define SHM_SIZE 4096
 
int main(void)
{
    key_t key = ftok(".", 0x6666);
    int shmid = shmget(key, SHM_SIZE, IPC_CREAT | IPC_EXCL | 0666);
    if (shmid < 0) {
        perror("shmget");
        return 1;
    }
 
    char *addr = shmat(shmid, NULL, 0);
    if (addr == (char *)-1) {
        perror("shmat");
        return 1;
    }
 
    strcpy(addr, "hello from creator");
    printf("attached at %p, content: %s\n", (void *)addr, addr);
 
    shmdt(addr);
    shmctl(shmid, IPC_RMID, NULL);
    return 0;
}

注意 shmat 失败时返回的是 (void *)-1,不是 NULL。课件里那段客户端写的是 if (shmaddr == nullptr),这个判断永远不成立,挂接失败会带着一个假指针继续往下跑。

struct shmid_ds 记录这段共享内存的状态:权限 shm_perm、大小 shm_segsz、最后挂接/脱离/变更时间、创建者与最后操作者的 pid、当前挂接数 shm_nattch。课件贴的是内核版本,字段名带 __kernel_ 前缀;用户空间 <sys/shm.h> 里的同名结构字段含义一致,类型不同,写代码时以头文件为准。

排查用两个命令:

ipcs -m                 # 列出所有共享内存段:key/shmid/owner/perms/bytes/nattch
ipcrm -m 688145         # 按 shmid 删除

课件里那个"第二次启动报 shmget: File exists"的现象,就是上一轮进程被 Ctrl+C 杀掉、IPC_RMID 没执行,段还留在内核里。System V 的 IPC 资源生命周期随内核,进程死了它不死,只有重启或者 ipcrm 能清掉。工程上要么在程序里处理信号并清理,要么每次启动先用 IPC_CREAT(不带 EXCL)拿已有的段。

共享内存最大的坑是没有同步与互斥。管道自带同步——读空就阻塞;共享内存什么都没有,两个进程同时写同一块地址,读到的是谁的、写进去的顺序对不对,全看运气。要控制顺序,可以借一根管道做门闩:写方写完共享内存后往管道里写一个字节,读方先从管道读,读到了才去读共享内存。管道的阻塞点成了天然的屏障。

消息队列与信号量

消息队列在内核里维护一个链表,每个节点是一块带类型的数据:

int msgget(key_t key, int msgflg);
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

msgp 指向的结构体第一个字段必须是 long mtype。接收方可以按类型取,也可以只取某一类,这就比管道的纯字节流多了一层消息边界。它和共享内存同样属于 System V 家族,生命周期随内核。

信号量的概念比接口重要。先把几个词分清:

  • 多个执行流能看到的同一份资源叫共享资源;
  • 被保护起来、一次只允许一个执行流访问的共享资源叫临界资源;
  • 访问临界资源的那段代码叫临界区,其余叫非临界区;
  • 任何时刻只允许一个执行流进入临界区,叫互斥;
  • 多个执行流访问临界资源时有确定的先后顺序,叫同步。

一段代码被切成三段:非临界区、加锁进入的临界区、解锁退出后的非临界区;所谓保护共享资源,保护的是访问它的这段代码

信号量是一个计数器,本质是对资源的预订:申请资源时计数器减一(P 操作),释放时加一(V 操作)。计数器为 0 还继续 P,进程就阻塞,直到有人 V。System V 的接口是 semget/semop/semctl,一次可以操作一组信号量,semctl 的 SETVAL 用来设置初值。计数大于 1 时它退化成"限流",等于 1 时就是互斥锁。

两套接口怎么选

System V 与 POSIX 的对照:

维度System VPOSIX
标识key_t,靠 ftok 约定文件名(/name 形式)或 fd
生命周期随内核,进程退出不回收共享内存/信号量随文件系统,消息队列可 mq_unlink
共享内存接口shmget / shmat / shmdt / shmctlshm_open / mmap / shm_unlink
消息队列接口msgget / msgsnd / msgrcvmq_open / mq_send / mq_receive
同步原语只有信号量信号量、互斥量、条件变量、读写锁
查询工具ipcs / ipcrmls /dev/shm

老代码和教材示例多用 System V,因为接口直观、字段少;新代码倾向 POSIX,因为它用文件名而不是魔数 key,权限和清理可以交给文件系统,还能和线程同步原语统一使用。

内核怎么同时管这三类资源?它们共用一套骨架。util.h 里 struct ipc_ids 描述一类 IPC 的整体:in_use 用了几个、max_id 最大编号、seq 序号、一把 mutex,以及指向 struct ipc_id_ary 的 entries。ipc_id_ary 里是一个 struct kern_ipc_perm * 数组,每个元素指向一个具体资源的权限结构。

左边是 struct ipc_ids 的定义,右边是 ipc_id_ary 与 sem_init/msg_init/shm_init 三个初始化入口:三类资源用同一套 id 分配逻辑,具体对象通过 kern_ipc_perm 指针数组定位

于是 shmid、msqid、semid 这三类 id 本质都是"数组下标 + 序号"的打包,用 shmget 拿到的 id 直接在数组里定位到那个 kern_ipc_perm,再按资源类型转换到具体的结构体。这也是为什么 ipcs 能把三种资源用一个格式列出来。