前言
进程之间要交换数据,就需要建立通信。理解这些通信方式时,我先从管道入手,再梳理 System V 共享内存、消息队列和信号量,最后把它们和 IPC 资源管理、文件映射联系起来。
| 大纲 | 内容 | 记忆重点 |
|---|---|---|
| 通信目的 | 数据传输 | 一个进程把数据交给另一个进程 |
| 通信目的 | 资源共享 | 多个进程共同访问同一份资源 |
| 通信目的 | 通知事件 | 通知其他进程发生了某件事 |
| 通信目的 | 进程控制 | 观察或控制其他进程的执行状态,例如调试 |
| 基本思路 | 找到共同可访问的资源 | 进程地址空间独立,通信需要建立联系 |
| 接口脉络 | 管道、System V IPC、POSIX IPC | 按不同接口体系梳理通信与同步机制 |
| 管道 | 匿名管道、命名管道 | 用字节流传递数据 |
| System V IPC | 消息队列、共享内存、信号量 | 分别对应消息传递、共享数据、资源协调 |
| POSIX IPC | 消息队列、共享内存、信号量 | 与 System V 的接口体系不同 |
| 相关 POSIX 同步工具 | 互斥量、条件变量、读写锁 | 组织执行流对共享资源的访问 |
互斥量、条件变量和读写锁用于跨进程同步时,还需要满足进程共享属性与共享存储等条件,不能把各进程私有的同步对象当成同一把锁。
一、管道
管道是 UNIX 操作系统最古老的进程通信方式。把一个进程连接到另一个进程的数据流,称为管道。两个进程之间的数据流向见图 1。

图 1:管道连接两个进程的数据流。
1.1 匿名管道
匿名管道通过 pipe() 创建,用两个 fd 分别表示读端和写端。
1.1.1 原理
先调用 pipe() 创建管道,取得读写两个 fd。fd 的分配遵循最小可用文件描述符原则,从小到大分配。
接着调用 fork() 创建子进程。子进程继承父进程对 struct file 的引用,也就获得了管道的读写能力;父子进程共享这些结构体。之后,双方分别关闭不需要的读端或写端,确定数据的流向。
通信在内核缓冲区里完成。我先把这个过程理解成"写一个、读一个",不会覆盖另一个进程尚未读取的数据。(相关文档:pipe(7):字节流与读写)
1.1.2 pipe 的特点
pipe(int arr[2]) 中,arr[0] 表示从管道读,arr[1] 表示向管道写。
- 数据在内核缓冲区中传递。
- 数据不会持久化。
- 进程结束,数据也就没了。(相关文档:pipe(7):端点关闭与管道生命周期)
- 本质上是在内存中组织 FIFO 队列,也就是先写先读。
1.1.3 fork 后 fd 表与管道对象的关系
fork() 后,父子进程拥有各自独立的 fd 表。fd 表不在 struct file 内部,表项会指向对应的 struct file。
父子进程中对应的 fd 表项会指向同一个 struct file。对于管道来说,struct file 又会指向同一个 pipe 对象,也就是内核中的环形缓冲区。父子进程通过这个共享缓冲区完成通信,整体关系见图 2 和图 3。(相关文档:fork(2):文件描述符继承;Linux v6.12:管道文件对象)

图 2:关闭多余端点后形成父写子读通路。
按图 2 的设定,pipefd[0] 为 3,pipefd[1] 为 4;这两个具体数值只是图中的取值。fork() 后,父子进程都持有读端和写端。若让父进程写、子进程读,就由父进程关闭自己的读端 close(3),子进程关闭自己的写端 close(4),留下"父写 → 管道 → 子读"这条通路。两端操作的都是各自的 fd 表,不会把对方仍持有的端点一并关掉。
通信方向可以这样区分:
| 通信方式 | 数据方向 | 双方能否同时发送 | 和管道的关系 |
|---|---|---|---|
| 单工 | A → B | 只沿一个方向传输 | 一条普通 Linux 管道提供一个方向的通道 |
| 半双工 | A → B 或 B → A,轮流进行 | 不能同时双向发送 | 若协议安排双方轮流收发,就是半双工;单条普通管道不会自动调转方向 |
| 全双工 | A → B,同时 B → A | 可以 | 可用两条独立的普通管道,分别承载两个方向 |
匿名管道可以理解为由内核管理的内存文件对象:没有可按路径打开的名字,创建时直接使用 pipe() 得到读写 fd,不需要先打开一个磁盘文件,通信数据也不写入磁盘文件。

图 3:fd 表、struct file 与管道对象的关系。(相关文档:Linux v6.12:create_pipe_files;pipe_inode_info 结构)
| 组件 | fork 后的状态 | 说明 |
|---|---|---|
| fd 表 | 父子独立 | 数组复制,各自管理 fd |
| fd 表元素 | 指向 struct file | 指针共享,不复制 struct file |
| struct file | 父子共享一份 | 管理偏移量、引用计数、缓冲区、同步 |
| pipe_inode_info | 父子共享一份 | 管道缓冲区、读写顺序和阻塞机制统一 |
(相关文档:Linux v6.12:pipe_inode_info)
c
#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
int main()
{
int arr[2];
pipe(arr);
pid_t pid = fork();
if(pid < 0)
{
// error
return -1;
}
else if(pid == 0)
{
// child
// 写数据,关闭读
close(arr[0]);
while(1)
{
char tmp[] = "你好pipe";
write(arr[1],tmp,sizeof(tmp));
printf("child发送:%s\n",tmp);
sleep(1);
}
}
// parent
// 读数据,关闭写
close(arr[1]);
while(1)
{
char tmp[1024];
ssize_t n = read(arr[0],tmp,sizeof(tmp));
if(n<0) break;
tmp[n-1] = 0;
printf("parent读取:%s\n",tmp);
sleep(1);
}
return 0;
}

1.2 匿名管道特性和情况
- 单向通信。 管道的数据流向是单向的,对应的通信模式是单工通信。
- 用于具有血缘关系的进程。 匿名管道用于父子进程或兄弟进程之间的通信。(相关文档:pipe(2):创建及 fork 示例)
- 面向字节流。 并不是写一次就必须读一次。写端可以一次写入一串数据,读端按照指定的字节数读取。
- 生命周期随进程。 管道有引用计数。子进程结束或关闭管道文件时,引用计数减一;父进程结束,管道就直接结束。(相关文档:pipe(7):关闭端点)
- 自带互斥与同步机制。 多进程通过管道通信时,内核会管理共享缓冲区的访问。
我把这里的互斥理解为:在多进程通信中,谁正在读写缓冲区,就先让谁完成,不会乱序,也不会覆盖尚未读取的数据,也就是同一时刻只允许一个执行流访问资源。
同步则可以结合 FIFO 来理解:数据进入管道后,读端才能读取。多个进程向一个进程写数据时,先让一个进程写完,再轮到另一个进程写。多写者与管道缓冲区的关系见图 4。(相关文档:pipe(7):PIPE_BUF 与多写者)

图 4:多写者经管道缓冲区向读端传递字节流。
| 特性 | 互斥 | 匿名管道写同步 |
|---|---|---|
| 谁控制同步 | 程序员 | 内核 |
| 是否必须显式加锁 | 是 | 否 |
| 同时访问是否安全 | 需要锁保证 | 内核保证不超过 PIPE_BUF 的写入具有原子性 |
| 是否保证顺序 | 不保证顺序 | 保证写入顺序,FIFO |
| 例子 | 多线程修改同一全局变量 | 多进程向管道写数据 |
1.3 匿名管道的四种情况
- 写得慢,读端等待。 子进程写得慢,父进程就会阻塞,等待管道里有数据后再读取。
- 管道写满,写端等待。 子进程写得快,父进程不读,管道一旦写满,子进程就必须阻塞,等待父进程读取。
- 写端关闭,读完剩余数据。 写端关闭后,读端先读完管道中剩余的数据;随后读到空字符,表示到达管道尾部,不能再读,程序也就要结束了。
- 读端关闭,写端继续写。 读端关闭 fd 后,写端继续写已经失去通信意义,操作系统会直接杀死写进程。(相关文档:pipe(7):阻塞、EOF 与 SIGPIPE)
c
#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
int main()
{
int arr[2];
pipe(arr);
pid_t pid = fork();
if(pid < 0)
{
// error
return -1;
}
else if(pid == 0)
{
// child
// 写数据,关闭读
close(arr[0]);
int i = 0;
while(1)
{
char tmp[] = "你好pipe";
printf("等待写入...\n");
write(arr[1],tmp,sizeof(tmp));
printf("child发送:%s\n",tmp);
// 1.写慢,读快
// sleep(5);
// 2.写快,读慢
// 3.写端关闭
// if((i++) == 10)
// {
// close(arr[1]);
// return 0;
// }
}
}
// parent
// 读数据,关闭写
close(arr[1]);
while(1)
{
char tmp[10240];
printf("等待写入...\n");
ssize_t n = read(arr[0],tmp,sizeof(tmp));
if(n<0) break;
tmp[n-1] = 0;
printf("parent读取:%s\n",tmp);
// 1.写慢,读快
// sleep(1);
// 2.写快,读慢
// sleep(5);
// 4.读关闭
close(arr[0]);
}
return 0;
}
1.写慢,读快

2.写快,读慢(写满管道)

3.写关闭(等待数据读完,read返回0,结束)

4.读关闭(直接结束)

1.4 命名管道
匿名管道没有名字。接下来看的命名管道,则可以通过路径找到。
创建命名管道使用 mkfifo(const char *path, mode_t mode),其中 mode 表示文件权限;删除命名管道使用 unlink(const char *path)。
命名管道在文件系统中有一个占位符,有自己的 inode 标识符,也有路径和目录项。通信数据不会刷新到磁盘,而是写入内核缓冲区,等待另一个进程读取。通过这个入口,没有父子等血缘关系的进程也能通信。
通信开始之前,如果读端先打开、写端还没打开,读端的 open() 会阻塞,直到写端打开。
还要把"等待对端打开"和"对端已经关闭"区分开。如果管道之前已经通过 open() 打开,而后对端关闭,再进行读写,就会返回 0 并直接退出。(相关文档:fifo(7):打开规则;pipe(7):读写端关闭)
二、System V 共享内存
System V 共享内存必须开辟 4096 字节的整数倍。(相关文档:shmget(2):size 与 PAGE_SIZE)
2.1 原理
接着看共享内存。它是在物理内存中开辟一个共享区域,让不同进程能够看到、使用同一份资源。
只有内存块还不够,操作系统还要管理创建者、访问权限等信息。因此,我把共享内存理解为:
共享内存 = 管理结构体 + 内存块。
具体做法是,通过进程虚拟地址空间中的共享区建立页表映射,让不同进程最终映射到同一份物理内存,使用同一份资源。这个思路和动态库的映射有相似之处(动态库映射:博客),见图 5。

图 5:不同进程通过页表映射到同一份共享内存。
共享内存使用时,可以按下面的顺序理解:
- 创建或获取资源:拿到共享内存段的标识符。
- 建立挂接:让该段进入当前进程的虚拟地址空间。
- 访问数据:通过挂接地址访问共享区域。
- 解除挂接:当前进程不再通过这段地址访问它。
- 释放资源:对不再需要的共享内存段执行删除管理。
把这五步分开记,才能区分"当前进程不再使用"和"共享资源本身不再存在"。
2.2 创建与删除共享内存
2.2.1 shmget
创建共享内存块使用 shmget(key_t key, size_t size, int shmflg)。
key:共享内存的 key 值,用于识别共享内存块,也用于让不同进程找到要交流的内存块。size:共享内存的大小,要求是 4096 字节的整数倍。(相关文档:shmget(2):size 参数)shmflg:创建标志以及共享内存的权限。
我的理解是,这些进程没有通过血缘关系继承资源,也没有同一个文件 fd 作为中间值,所以要由用户提供 key,让操作系统知道要找哪块内存。
key 可以自己指定,也可以使用 ftok(const char *pathname, int proj_id) 生成。(相关文档:ftok(3):key 生成规则;shmget(2):key)
IPC_EXCL 配合 IPC_CREAT 使用:
- 带
IPC_EXCL:不存在就创建,存在就报错,要求得到一块新的共享内存。 - 不带
IPC_EXCL:没有就创建,有就获取已经存在的内存块。(相关文档:shmget(2):IPC_CREAT 与 IPC_EXCL)
2.2.2 生命周期与删除
共享内存块创建后,不会随着某个进程的结束而消失,而是随操作系统存在。
删除有两种方式:
- 使用
ipcrm -m key。key 和 shmid 可以通过ipcs -m查询。 - 使用
shmctl(int shmid, int op, struct shmid_ds *buf),将op设为IPC_RMID。(相关文档:shmctl(2):IPC_RMID;ipcrm(1):删除选项)
这里的 op 相当于要执行的操作。shmctl() 可以获取或修改 shmid_ds 结构体中的 op 属性。相关管理结构如下。(相关文档:shmctl(2):操作参数与管理结构)
共享内存的管理结构
下面列出主要成员,具体类型、保留字段和布局以目标系统头文件为准。
c
struct shmid_ds {
struct ipc_perm shm_perm; // 所有者和访问权限
size_t shm_segsz; // 共享内存段大小,单位为字节
time_t shm_atime; // 最近一次挂接时间
time_t shm_dtime; // 最近一次去关联时间
time_t shm_ctime; // 创建或最近一次控制修改时间
pid_t shm_cpid; // 创建者进程 ID
pid_t shm_lpid; // 最近一次挂接或去关联的进程 ID
shmatt_t shm_nattch; // 当前挂接数量
/* 省略实现相关的其他字段 */
};
struct ipc_perm {
key_t __key; // 创建或查找资源使用的 key
uid_t uid; // 当前所有者的用户 ID
gid_t gid; // 当前所有者的组 ID
uid_t cuid; // 创建者的用户 ID
gid_t cgid; // 创建者的组 ID
unsigned short mode; // 访问权限及相应状态标志
unsigned short __seq; // 内部序列号
};
shm_perm 内嵌的是公共权限结构;shm_segsz 描述数据区域有多大;shm_nattch 描述当前还有多少个挂接。ipc_perm 各成员的含义在 5.2 节继续说明。
2.3 共享内存的特点
- 访问时不需要系统调用。 共享内存已经通过页表映射到进程地址空间,访问时可以直接使用。
- 数据拷贝少,通信快。 写端只需要拷贝一次数据,写入后其他读端就能立刻看到,可以把它理解为通信速度最快的方式。
- 需要自己保护资源。 共享内存没有资源保护机制,也没有互斥和同步,需要由程序员自己处理。(相关文档:shmctl(2):访问权限;shm_overview(7):共享内存与同步)
2.4 key 和 shmid 的区别
可以先借助 inode 和 fd 的关系来理解:
- key 面向操作系统,用于表示共享内存的唯一性,可以类比 inode。
- shmid 面向用户,代码中使用 shmid 操作共享内存,可以类比 fd。(相关文档:shmget(2):key 与共享内存标识符)
2.5 挂接与去关联
有了共享资源,下一步就是把它挂接到对应进程的地址空间中,再通过挂接地址使用它。
挂接使用 shmat(int shmid, const void *shmaddr, int shmflg),返回值是共享内存的起始地址。
shmid:共享内存标识符。shmaddr:希望挂接到的虚拟地址空间起始地址。一般传空指针,让操作系统选择映射地址。shmflg:挂接时的标志。(相关文档:shmat(2):地址、标志及返回值)
去关联使用 shmdt(const void *shmaddr)。这里传入的是共享内存在当前进程虚拟地址空间中的起始地址。挂接数量可以通过下面的命令查看。
查看挂接数的命令示例
bash
ipcs -m
需要看某一段的详细信息时,使用 ipcs -m -i <shmid>,把 <shmid> 换成实际的共享内存段 ID。
ipcs -m 默认列表中的常见列,可以这样读:
| 列名 | 含义 | 阅读时关注什么 |
|---|---|---|
| key | 资源的查找键 | 用于按约定找到对应资源,不是挂接地址 |
| shmid | 共享内存段 ID | 查看某一段详情、挂接和管理时使用的标识符 |
| owner | 当前所有者 | 通常显示用户名,不是"当前正在读写的进程" |
| perms | 访问权限的八进制表示 | 例如读写权限;不是挂接数 |
| bytes | 该共享内存段的大小 | 单位是字节,不表示当前写入了多少数据 |
| nattch | 当前挂接数 | 对应 shm_nattch,表示还有多少个有效挂接 |
| status | 附加状态 | 可能为空;dest 表示已标记删除,locked 表示锁定在内存中 |
挂接数应按"挂接关系"理解,不能一律当成去重后的进程数:同一个进程可以多次挂接同一段。shmat() 成功会增加挂接,shmdt() 会解除对应挂接。nattch 为 0 也不代表这块共享内存已经被删除。
三、消息队列
消息队列是在内核中以队列形式传递消息的一种通信方式。
3.1 按类型传递数据块
再来看消息队列。创建队列后,不同进程获取同一个队列,通过发送和接收数据完成通信。
理解消息队列时,我主要记住这几个细节:
- 消息队列可能同时存在多份,操作系统需要先描述、再组织,对它们进行管理。
- 消息队列有队列头,也有描述它的结构体;沟通只要一个进程即可。
- 多个进程可以通过消息类型区分数据。比如 A、B、C 三个进程使用一个队列,可以通过类型封装数据,区分数据是给谁的。
这样,进程通过共享一个队列,实现基于带类型的数据块 的进程间通信。这里传递的是一个个结构体中的数据块,可以和前面的字节流对照着理解。(相关文档:msgop(2):消息类型与接收规则)
3.2 消息队列接口
msgget(key_t key, int msgflg):获取消息队列标识符 msqid。参数思路与shmget()类似。msgctl(int msqid, int op, struct msqid):获取或修改描述消息队列的结构体属性,也可以删除消息队列。msgsnd(msqid, msgp, msgsz, msgflg):发送消息。msgp指向包含mtype和mtext的结构体,msgsz表示数据大小。msgrcv(msqid, msgp, msgsz, msgtyp, msgflg):接收消息。msgp是接收缓冲区,msgtyp用来指定需要接收的类型。(相关文档:msgctl(2):接口声明;msgop(2):msgsz 与消息结构)
消息结构的两个成员
c
struct msgbuf {
long mtype; // 消息类型,必须大于 0
char mtext[1]; // 消息数据区,长度由应用按实际需要安排
};
mtype 用于分类和选择消息,mtext 存放消息内容。这里的 mtext[1] 是说明成员形式的写法,不表示实际消息只能有一个字节。
| 函数 | 作用 | 主要参数 | 返回值 | 关键说明 |
|---|---|---|---|---|
| msgsnd | 向 System V 消息队列发送一条消息 | msqid、msgp、msgsz、msgflg | 成功返回 0,失败返回 -1 | mtype 必须大于 0;msgflg 为 0 时阻塞,IPC_NOWAIT 表示队列满时立即返回 |
| msgrcv | 从 System V 消息队列接收一条消息 | msqid、msgp、msgsz、msgtyp、msgflg | 成功返回实际接收的 mtext 字节数,失败返回 -1 | msgtyp 为 0 时取第一条;大于 0 时取指定类型;小于 0 时取不超过其绝对值的最小类型;支持 IPC_NOWAIT 和 MSG_NOERROR |
MSG_NOERROR 表示接收超长消息时允许截断。
c
/* System V 消息队列: 按 mtype 分类发送, 三种 msgtyp 取法
* 编译运行: gcc test1.c -o test1 && ./test1 (Linux/WSL)
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/wait.h>
#include <unistd.h>
struct msgbuf { long mtype; char mtext[64]; }; /* mtype>0 只是分类标签, mtext 才是数据 */
int main(void)
{
int msqid = msgget(IPC_PRIVATE, IPC_CREAT | 0666); /* 拿队列句柄, 用法类比 shmget */
struct msgbuf m, r; struct msqid_ds ds; /* ds: 内核描述该队列的结构体 */
long t[3] = { 10, 5, 1 };
for (int i = 0; i < 3; i++) { /* 故意按 10 → 5 → 1 的顺序入队 */
m.mtype = t[i];
sprintf(m.mtext, "给类型%ld的数据", m.mtype);
msgsnd(msqid, &m, strlen(m.mtext) + 1, 0); /* msgsz 只算 mtext, 不含 mtype */
}
msgctl(msqid, IPC_STAT, &ds); /* 只读属性: 队里现有几条 */
printf("入队后 msg_qnum=%lu\n", (unsigned long)ds.msg_qnum);
if (fork() == 0) { /* 子进程扮演"另一个进程"来收 */
msgrcv(msqid, &r, sizeof r.mtext, 5, 0); /* msgtyp>0 : 点名只要 type==5 */
printf("[msgtyp= 5] %s (mtype=%ld)\n", r.mtext, r.mtype);
msgrcv(msqid, &r, sizeof r.mtext, -9, 0); /* msgtyp<0 : 取 <=9 中最小的类型 → 1 */
printf("[msgtyp=-9] %s (mtype=%ld)\n", r.mtext, r.mtype);
msgrcv(msqid, &r, sizeof r.mtext, 0, IPC_NOWAIT);/* msgtyp= 0 : 取队首第一条 → 10 */
printf("[msgtyp= 0] %s (mtype=%ld)\n", r.mtext, r.mtype);
printf("[空队列再收] 返回 %ld, IPC_NOWAIT 不阻塞\n",
(long)msgrcv(msqid, &r, sizeof r.mtext, 0, IPC_NOWAIT));
exit(0);
}
wait(NULL);
msgctl(msqid, IPC_RMID, NULL); /* 删队列: 谁建谁删 */
return 0;
}

四、信号量
4.1 用计数器描述资源
前面几种方式关注数据怎样传递,接着看并发访问怎样协调。信号量主要用来解决并发访问中数据不一致的问题,本质上是一个计数器。多个进程访问公共资源时,先通过信号量了解资源的使用情况,再判断自己能否独立使用其中的一份资源。(相关文档:semget(2):信号量集合;semop(2):申请与归还资源)
我会拿电影院来理解:访问资源就像买票,先预订一个位置,再进去使用。电影院的总座位数相当于信号量,可以保证互斥。(相关文档:semop(2):计数与操作条件)
4.2 并发问题解决
多个执行流共同看到并访问公共资源时,需要使用信号量保护。通过一定的算法,保证一个进程预订的资源不会再被其他进程使用。
任何时刻只有一个执行流访问公共资源或临界区,这就叫互斥。
信号量计数通过 P 操作申请资源,通过 V 操作归还资源。要靠这套机制保护临界区,首先得保证操作信号量本身不会被其他执行流"插进来改一半"。
原子性的判断重点,是并发执行流能不能观察或干扰操作的中间状态。 对其他参与者来说,一次原子操作表现为不可分割的一步,而不是先看到更新了一半、再看到剩下一半。这里说的原子性,是并发访问语义,不等同于发生错误时自动回滚。
从 CPU 和汇编这一层看,需要关注指令本身提供了什么保证。一条由目标 CPU 保证原子性的指令,可以作为原子操作的基础;只数"一行汇编"还不够,还要看指令、操作数大小、对齐以及多核访问条件。 也就是说,"汇编层面的一步"这个理解要落在 CPU 的原子保证上。
更长的临界区则可以配合信号量和访问协议:进入前申请,允许进入才操作共享资源,完成后归还。这样可以形成一条理解链路:
底层原子保证 → 安全地维护信号量 → 按协议进入临界区 → 保护共享资源。
对 System V 信号量,应用调用 semop(),由内核保证同一次调用中的操作数组整体完成或整体不执行。信号量不会把临界区中的每条指令变成 CPU 原子指令,而是协调执行流,避免它们不受控制地同时修改受保护的数据。
4.3 多元信号量与二元信号量
- 多元信号量:通过算法,保证进程能够访问自己预订的资源。
- 二元信号量:用于互斥。
每个进程访问公共资源前,都要申请信号量。如果在每个进程里各放一个互不相关的全局变量,大家看到的就不是同一份计数器。
所以,信号量本身也是公共资源,需要在内核中维护,让不同进程都能操作同一份计数器。按这个思路,它也属于 IPC。(相关文档:semget(2):System V 信号量;semop(2):内核操作接口)
4.4 信号量接口
4.4.1 semget
c
int semget(key_t key, int nsems, int semflg);
获取或创建信号量集合,返回 semid。
key:用于查找对应的信号量集合。nsems:需要申请的信号量个数,不是信号量的初始值。semflg:创建标志和权限,包含IPC_CREAT、IPC_EXCL等。
4.4.2 semctl
c
int semctl(int semid, int semnum, int op, ...);
semnum 是信号量集合内的索引,0 表示第一个;op 指定要执行的操作。
4.4.3 semop
c
int semop(int semid, struct sembuf *sops, size_t nsops);
struct sembuf {
unsigned short sem_num; // 信号量集合内的索引
short sem_op; // 负数为 P 操作,正数为 V 操作,0 为等待值变成 0
short sem_flg; // IPC_NOWAIT、SEM_UNDO 等
};
sops 指向操作数组,nsops 是数组中操作的数量。常见情况下是 1,也可以通过多个操作组成原子事务。semop() 用来对信号量进行原子性的增加、减少等操作。相关的管理结构和控制参数如下。
信号量集合的管理结构
c
struct semid_ds {
struct ipc_perm sem_perm; // 所有者和访问权限
time_t sem_otime; // 最近一次成功 semop 的时间
time_t sem_ctime; // 创建或最近一次 semctl 修改时间
unsigned long sem_nsems; // 集合中信号量的个数
};
sem_nsems 是集合里有几个信号量,不是某个信号量当前的计数值。sem_perm 使用的是前面列出的 ipc_perm。
semctl 第四参数使用的联合体
c
union semun {
int val; // SETVAL:设置一个信号量的值
struct semid_ds *buf; // IPC_STAT / IPC_SET:读写管理信息
unsigned short *array; // GETALL / SETALL:读写一组计数值
struct seminfo *__buf; // IPC_INFO:Linux 的系统级信息
};
union 的成员共用存储空间,具体使用哪个成员,取决于 semctl() 的操作。
c
/* 信号量: 先用 GETVAL 数"座位", 再用 P/V 保护多个进程对共享计数器的 ++
* gcc test1.c -o test1 && ./test1 && ./test1 lock */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/wait.h>
union semun { int val; struct semid_ds *buf; unsigned short *array; }; /* 第4参要自己定义 */
int main(int argc, char **argv)
{
int lock = argc > 1; (void)argv; /* 带参数 = 加 P/V 保护 */
int semid = semget(IPC_PRIVATE, 1, IPC_CREAT | 0666); /* nsems=1: 集合里一个信号量 */
union semun u = { .val = 2 }; /* 2 个座位 -> 多元信号量 */
semctl(semid, 0, SETVAL, u);
struct sembuf P = { 0, -1, IPC_NOWAIT }, V = { 0, +1, 0 };
int a = semop(semid, &P, 1), b = semop(semid, &P, 1), c = semop(semid, &P, 1);
printf("座位=2, 连做三次 P: %d %d %d -> 第三次没座位, 现在 GETVAL=%d\n",
a, b, c, semctl(semid, 0, GETVAL));
semop(semid, &V, 1); semop(semid, &V, 1); /* 两次 V 还回去 -> 又是 2 */
semctl(semid, 0, SETVAL, 1); /* 降到 1 -> 二元信号量 = 互斥锁 */
int shmid = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT | 0666);
volatile int *cnt = shmat(shmid, NULL, 0); *cnt = 0; /* 共享计数器, 公共资源 */
for (int i = 0; i < 2; i++) if (fork() == 0) { /* 两个进程同时抢 */
struct sembuf p = { 0, -1, SEM_UNDO }, v = { 0, +1, SEM_UNDO };
for (int n = 0; n < 200000; n++) {
if (lock) semop(semid, &p, 1); /* P: 申请进临界区 */
*cnt = *cnt + 1; /* 读-改-写, 本身不原子 */
if (lock) semop(semid, &v, 1); /* V: 归还 */
}
exit(0);
}
while (wait(NULL) > 0);
printf("%s -> cnt = %d (期望 400000)\n", lock ? "加 P/V" : "不加锁", *cnt);
semctl(semid, 0, IPC_RMID, 0); shmctl(shmid, IPC_RMID, NULL); /* 不清会长住 */
return 0;
}

五、查看 IPC 指令
5.1 查看与删除 IPC 资源
ipcs 用于查看 IPC 资源,ipcrm 用于删除 IPC 资源。
| 资源 | 查看 | 删除 |
|---|---|---|
| 共享内存 | ipcs -m | ipcrm -m shmid |
| 消息队列 | ipcs -q | ipcrm -q msqid |
| 信号量 | ipcs -s | ipcrm -s semid |
5.2 IPC 资源的统一管理
前面分别看了共享内存、消息队列和信号量,再把它们放到一起理解:它们采用统一的 System V IPC 接口思路,都有 key,操作系统也需要把这些资源组织起来。
可以理解为,内核通过 ipc_id_arr 管理三类结构体,内部使用 kern_ipc_perm * 数组组织这些对象,因为它们都有 struct ipc_perm 这样的公共权限结构。公共权限结构及各成员含义如下。(相关文档:Linux v6.12:ipc_ids;kern_ipc_perm)
公共权限结构 ipc_perm
c
struct ipc_perm {
key_t __key;
uid_t uid;
gid_t gid;
uid_t cuid;
gid_t cgid;
unsigned short mode;
unsigned short __seq;
};
| 成员 | 含义 | 和其他成员的区别 |
|---|---|---|
| __key | 与资源关联的 key | 是查找键,不是进程的虚拟地址 |
| uid | 当前所有者的用户 ID | 与创建者的 cuid 分开记录 |
| gid | 当前所有者的组 ID | 与创建者的 cgid 分开记录 |
| cuid | 创建者的用户 ID | 表示创建时的身份 |
| cgid | 创建者的组 ID | 表示创建时所属的组 |
| mode | 访问权限,部分资源还带有状态标志 | 低 9 位表示所有者、组、其他用户的权限 |
| __seq | 内部序列号 | 由实现维护,不是应用自己分配的业务编号 |
共享内存的 shm_perm、消息队列的 msg_perm、信号量集合的 sem_perm,都使用这套公共权限信息。这里列的是用户接口可见的成员;内核使用的 kern_ipc_perm 是另一层结构,不能因为名字接近就当成同一个类型。
5.3 用 C 语言理解 IPC 中的多态
沿着这些公共结构继续看,知道各个结构体的起始地址后,就可以调用不同 IPC 数据结构对应的方法,实现类似多态的效果。
Linux IPC 子系统可以结合三个结构理解:
ipc_ids:统一管理器。kern_ipc_perm:类似基类的公共部分。ipc_ops:函数指针表。
创建资源时,系统调用会进入与具体类型无关的通用函数 ipcget()。它使用具体类型提供的 ipc_ops,通过函数指针进入 newseg、newary 或 newque 等实现。
创建出来的对象由 ipc_ids 中的基数树以 kern_ipc_perm * 的形式统一管理。同一套公共管理逻辑驱动三类资源的创建与操作,我借此理解纯 C 语言中的多态,流程见图 6。(相关文档:Linux v6.12:ipcget;ipc_ids)

图 6:ipcget 按 ipc_ops 进入不同资源的创建路径。
5.4 POSIX 共享内存
前面主要围绕 System V IPC 展开。再看 POSIX 共享内存时,我会把它和前面的映射思路联系起来:
struct file → 文件 → 页缓存 → 物理页。
进程再通过页表,把自己的虚拟地址映射到这些物理页上,实现共享。

图 7:POSIX 与 System V 共享内存的普通页映射路径。
在 Linux 中,POSIX 共享内存通常通过 tmpfs 中的共享对象提供文件支持,再由 mmap() 映射到进程地址空间。System V 使用 shmget() 和 shmat() 这套接口;普通页路径在内核里同样可以由 shmem 文件支持。
两套接口最终都让进程通过页表访问共享对象的物理页。图 7 中左右两列分别表示各自对象的路径,不表示两套接口自动指向同一个对象,也不表示创建时就把全部物理页一次性准备好。
5.5 动态库与共享内存的联系
沿着文件映射这条线,还可以继续联系动态库加载:
磁盘上的 .so 文件 → 内核创建 struct file → 文件的页缓存与物理页 → 映射到进程虚拟地址空间。
动态库和 POSIX 共享内存,可以看作内存映射文件机制的"双生子":都依赖 struct file、页缓存和页表映射。一个映射磁盘上的 ELF 代码,另一个映射 tmpfs 中的共享数据,关系见图 8。

图 8:POSIX 共享内存与动态库的文件映射关系。
共同点是文件对象、页缓存和页表映射这条关系。POSIX 共享内存通常使用 MAP_SHARED,进程可以通过同一共享对象交换更新,访问时仍需要同步。动态库在 Linux 的常见加载路径中使用 MAP_PRIVATE:未修改的文件页可以被多个进程共享,可写私有页在写时复制后成为各自的副本。
所以图 8 两侧各有自己的文件对象和物理页,只是在使用同类映射机制;"都能共享物理页"不等于"写入都能互相看见"。
六、通信总结
最后,我把进程间通信的思路归纳成两步:
IPC 资源 = 内核数据结构 + 资源本身。
资源本身可以是内存块、队列或计数器;内核数据结构负责描述和管理这些资源。