Linux 系统编程 08：System V IPC

前言：

承接上一篇管道类 IPC，管道机制简单易用，但存在数据无边界、缓冲区有限、不适合复杂结构化数据交互等局限。本篇讲解 Linux 系统中经典的 System V IPC 三大核心机制：共享内存、消息队列与信号量。三者均由内核维护、具备独立生命周期，分别面向高性能数据传输、结构化消息收发、进程同步互斥三大场景，是多进程并发编程的核心工具，也是笔试面试的高频重点。

---

一、System V IPC 概述

1. 共性核心特征

System V IPC 包含共享内存（share memory）、消息队列（message queue）、信号量（semaphore）三类，它们遵循完全一致的设计范式：

• 内核对象：每类 IPC 都是内核中的一个对象，由内核统一管理，独立于任何进程
• 键值标识 ：通过key_t类型的键值唯一标识，多个进程通过同一个 key 找到同一个 IPC 对象
• 生命周期随内核：除非显式删除或系统重启，否则 IPC 对象会一直存在，进程退出不会自动销毁
• 命令行工具 ：均可通过ipcs查看、ipcrm删除，方便调试与运维

2. ftok 函数：生成 IPC 键值

多个进程需要约定同一个 key 才能访问同一个 IPC 对象，ftok用于根据文件路径和项目 ID 生成唯一的 key 值。

#include <sys/types.h>
#include <sys/ipc.h>

key_t ftok(const char *pathname, int proj_id);

• pathname：一个已存在的文件路径，基于文件的 inode 生成 key
• proj_id：项目 ID，取低 8 位，用于同一路径下区分不同 IPC 对象
• 返回值：成功返回生成的 key，失败返回 - 1

注意：只要路径和 proj_id 相同，生成的 key 就相同；文件被删除重建后 inode 变化，key 也会变化。

---

二、共享内存（Share Memory）

1. 本质与通信原理

共享内存是速度最快的进程间通信方式，原理是将同一块物理内存区域映射到多个进程的虚拟地址空间中。进程操作这段虚拟内存就相当于直接操作物理内存，数据不需要在内核和用户态之间来回拷贝，零拷贝特性使其性能远高于管道、消息队列等机制。

核心优缺点

• 优势：速度最快，无数据拷贝，适合大数据量传输
• 劣势：自身不提供同步互斥机制，多进程并发读写需要配合信号量或互斥锁使用

2. 核心操作函数

① 创建 / 获取共享内存：shmget

#include <sys/ipc.h>
#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);

• key：ftok 生成的键值，也可使用IPC_PRIVATE创建私有共享内存
• size：共享内存大小，单位字节，创建时必须指定，获取时可填 0
• shmflg：权限标志，常用IPC_CREAT | 0644，不存在则创建，存在则获取；加IPC_EXCL则存在时报错
• 返回值：成功返回共享内存 ID（shmid），失败返回 - 1

② 映射到进程地址空间：shmat

void *shmat(int shmid, const void *shmaddr, int shmflg);

• shmid：shmget 返回的共享内存 ID
• shmaddr：指定映射的虚拟地址，填 NULL 由内核自动分配
• shmflg：控制标志，填 0 表示可读可写，SHM_RDONLY表示只读
• 返回值：成功返回映射后的内存首地址，失败返回(void *)-1

③ 解除映射：shmdt

int shmdt(const void *shmaddr);

• 功能：将共享内存从当前进程地址空间分离，进程退出时也会自动解除
• 注意：解除映射不等于删除共享内存，内核对象依然存在

④ 控制共享内存：shmctl

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

• 常用cmd：
  • IPC_RMID：标记删除共享内存，实际会等到所有进程都解除映射后才真正销毁
  • IPC_STAT：获取共享内存属性信息
  • IPC_SET：设置共享内存属性

3. 实战：两个进程通过共享内存通信

写端进程 shm_write.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>
#include <unistd.h>

int main(void) {
    key_t key = ftok(".", 100);
    int shmid = shmget(key, 4096, IPC_CREAT | 0644);
    if (shmid == -1) {
        perror("shmget failed");
        return 1;
    }

    // 映射到进程空间
    char *p = shmat(shmid, NULL, 0);
    if (p == (void *)-1) {
        perror("shmat failed");
        return 1;
    }

    // 写入数据
    strcpy(p, "通过共享内存传输的字符串数据");
    printf("数据写入完成\n");

    // 解除映射
    shmdt(p);
    return 0;
}

读端进程 shm_read.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main(void) {
    key_t key = ftok(".", 100);
    int shmid = shmget(key, 0, 0);
    if (shmid == -1) {
        perror("shmget failed");
        return 1;
    }

    char *p = shmat(shmid, NULL, 0);
    if (p == (void *)-1) {
        perror("shmat failed");
        return 1;
    }

    printf("读到数据：%s\n", p);
    shmdt(p);

    // 读完删除共享内存
    shmctl(shmid, IPC_RMID, NULL);
    return 0;
}

---

三、消息队列（Message Queue）

1. 本质与通信原理

消息队列本质是内核中维护的一条链式消息队列，每个消息包含类型标识和数据内容。发送进程按类型追加消息，接收进程可以按指定类型读取消息，支持优先级读取。

核心特性

• 自带消息边界：一次发送对应一次接收，不会出现粘包问题
• 支持按类型读取：可以按消息类型选择性读取，实现优先级通信
• 生命周期随内核：进程退出后消息依然保留在内核中
• 存在两次拷贝：发送时从用户态拷贝到内核，接收时从内核拷贝到用户态，性能低于共享内存

2. 核心操作函数

① 创建 / 获取消息队列：msgget

#include <sys/ipc.h>
#include <sys/msg.h>

int msgget(key_t key, int msgflg);

• 参数规则与 shmget 一致，IPC_CREAT | 0644为常用创建模式
• 返回值：成功返回消息队列 ID（msqid），失败返回 - 1

② 发送消息：msgsnd

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

• msgp：消息结构体指针，必须以long mtype开头，后面跟自定义数据
• msgsz：消息正文的大小，不包含 mtype 的长度
• msgflg：0表示阻塞发送，队列满则等待；IPC_NOWAIT表示非阻塞，满则报错

标准消息结构体格式：

struct msgbuf {
    long mtype;       // 消息类型，必须大于0
    char mtext[1024]; // 消息正文，自定义大小
};

③ 接收消息：msgrcv

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

• msgtyp：读取的消息类型
  • > 0：读取指定类型的第一条消息
  • = 0：读取队列中第一条消息
  • < 0：读取类型小于等于其绝对值的、类型最小的第一条消息
• 返回值：成功返回读到的正文字节数，失败返回 - 1

④ 控制消息队列：msg

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

• 常用IPC_RMID删除消息队列，清空所有消息

3. 实战：消息队列收发

发送端 msg_send.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>

struct msgbuf {
    long mtype;
    char data[256];
};

int main(void) {
    key_t key = ftok(".", 200);
    int msqid = msgget(key, IPC_CREAT | 0644);

    struct msgbuf msg;
    msg.mtype = 1;
    strcpy(msg.data, "类型1的消息内容");

    msgsnd(msqid, &msg, strlen(msg.data), 0);
    printf("消息发送完成\n");
    return 0;
}

接收端 msg_recv.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>

struct msgbuf {
    long mtype;
    char data[256];
};

int main(void) {
    key_t key = ftok(".", 200);
    int msqid = msgget(key, 0);

    struct msgbuf msg;
    ssize_t n = msgrcv(msqid, &msg, sizeof(msg.data), 1, 0);
    if (n > 0) {
        printf("收到消息：%.*s\n", (int)n, msg.data);
    }

    msgctl(msqid, IPC_RMID, NULL);
    return 0;
}

---

四、信号量（Semaphore）

1. 本质与作用

信号量本质是一个内核维护的计数器，用于实现进程间的同步与互斥，本身不传输数据，只负责控制多个进程对共享资源的访问顺序。

• 二元信号量：初始值为 1，同一时间只允许一个进程访问资源，实现互斥功能
• 计数信号量：初始值大于 1，控制同时访问资源的进程数量

2. P/V 操作原理

信号量的核心操作是 P 操作（申请资源）和 V 操作（释放资源），两个操作都是原子的：

• P 操作：计数器减 1。如果减完后≥0，进程继续执行；如果 < 0，进程阻塞等待，直到有其他进程释放资源
• V 操作：计数器加 1。如果加完后≤0，说明有进程在等待，唤醒其中一个等待的进程

3. 核心操作函数

① 创建 / 获取信号量集：semget

#include <sys/sem.h>

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

• nsems：信号量集中信号量的个数，通常传 1
• 返回值：成功返回信号量集 ID（semid），失败返回 - 1

② PV 操作：semop

int semop(int semid, struct sembuf *sops, size_t nsops);

sembuf 结构体定义单个操作：

struct sembuf {
    unsigned short sem_num;  // 操作第几个信号量，从0开始
    short sem_op;            // 操作值：-1为P操作，+1为V操作
    short sem_flg;           // 0表示阻塞，IPC_NOWAIT非阻塞
};

③ 控制信号量：semctl

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

• 常用cmd：
  • SETVAL：设置信号量的初始值，第四个参数传联合体
  • IPC_RMID：删除信号量集
  • GETVAL：获取信号量当前值

4. 实战：二元信号量实现进程互斥

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>

// P操作：申请资源
void sem_p(int semid) {
    struct sembuf op;
    op.sem_num = 0;
    op.sem_op = -1;
    op.sem_flg = 0;
    semop(semid, &op, 1);
}

// V操作：释放资源
void sem_v(int semid) {
    struct sembuf op;
    op.sem_num = 0;
    op.sem_op = 1;
    op.sem_flg = 0;
    semop(semid, &op, 1);
}

int main(void) {
    key_t key = ftok(".", 300);
    int semid = semget(key, 1, IPC_CREAT | 0644);

    // 初始化信号量为1（二元信号量）
    semctl(semid, 0, SETVAL, 1);

    pid_t pid = fork();
    if (pid == 0) {
        sem_p(semid);
        printf("子进程进入临界区\n");
        sleep(2);
        printf("子进程离开临界区\n");
        sem_v(semid);
        _exit(0);
    }

    sem_p(semid);
    printf("父进程进入临界区\n");
    sleep(2);
    printf("父进程离开临界区\n");
    sem_v(semid);

    wait(NULL);
    semctl(semid, 0, IPC_RMID);
    return 0;
}

运行后两个进程不会同时打印临界区内容，说明信号量成功实现了互斥。

---

五、三种 System V IPC 对比与选型

对比维度	共享内存	消息队列	信号量
核心作用	大数据量传输，速度最快	结构化消息收发，带类型	进程同步与互斥，不传输数据
数据拷贝	零拷贝，直接操作内存	两次拷贝（用户→内核→用户）	无数据传输
同步机制	无，需额外配合	自带阻塞读写	本身就是同步机制
消息边界	无，流式	有，一次发送对应一次接收	-
性能	最高	中等	-
典型场景	大文件传输、视频帧共享	多进程指令交互、任务分发	共享资源互斥访问、进程同步

选型原则

• 追求极致性能、大数据量传输 → 共享内存 + 信号量
• 结构化消息、按优先级收发 → 消息队列
• 仅需要同步互斥控制 → 信号量

---

六、面试高频考点与易错坑点

1. 经典面试问答

Q1：为什么共享内存是最快的 IPC 方式？

答： 因为共享内存实现了零拷贝：同一块物理内存直接映射到多个进程的虚拟地址空间，进程读写数据直接操作内存，不需要在用户态和内核态之间来回拷贝数据。 而管道、消息队列等机制都需要先把数据从用户态拷贝到内核，再从内核拷贝到接收进程，两次拷贝开销大，因此共享内存速度最快。

Q2：System V IPC 的生命周期是怎样的？有什么注意事项？

答： System V IPC 的生命周期随内核，进程退出不会自动销毁 IPC 对象，必须显式调用 xxxctl 的 IPC_RMID 删除，或者用 ipcrm 命令删除，否则会一直存在直到系统重启。 这也是常见的资源泄漏原因，程序异常退出时容易残留 IPC 对象。

Q3：共享内存有什么缺点？实际使用中需要怎么解决？

答：

1. 共享内存自身不提供同步互斥机制，多进程并发读写时会出现数据竞争、内容错乱的问题。
2. 实际使用中需要配合信号量、文件锁或者互斥锁来做同步保护，保证同一时间只有一个进程写，或者读写互斥。

Q4：消息队列和管道相比有什么优势？

答：

1. 管道是流式无边界的，容易粘包；消息队列自带消息边界，一次发送对应一次接收。
2. 管道只能顺序读写；消息队列支持按消息类型读取，可以实现优先级通信。
3. 管道生命周期随进程；消息队列生命周期随内核，进程退出后消息依然保留。

Q5：信号量和互斥锁有什么区别？

答：

1. 作用范围：互斥锁用于线程间互斥，信号量可以用于进程间互斥同步。
2. 功能：互斥锁只能实现互斥；信号量既可以实现互斥（二元信号量），也可以实现同步，还能控制并发数量。
3. 实现层级：互斥锁通常在用户态实现；System V 信号量是内核对象，操作涉及系统调用。

2. 常见易错坑点

1. 程序退出忘记删除 IPC 对象，导致内核资源泄漏，多次运行后耗尽系统 IPC 资源
2. ftok 依赖文件 inode，文件被删除重建后 key 变化，进程间无法找到同一个 IPC 对象
3. 共享内存直接并发读写不加同步保护，导致数据错乱、读到脏数据
4. 消息结构体忘记以 long 类型的 mtype 开头，导致收发数据解析错误
5. 信号量创建后忘记初始化初始值，默认值为 0，导致 P 操作永久阻塞
6. 误以为共享内存删除后会立刻销毁，实际要等所有进程解除映射后才会真正释放
7. msgrcv 的第三个参数只传结构体总大小，没有减去 mtype 长度，导致内存越界

---

以上就是 System V IPC 三大机制的全部核心内容，掌握这三类工具可以应对绝大多数同主机多进程通信场景。下一篇我们将进入线程模块，讲解线程的本质、创建回收以及线程与进程的核心区别。

---

制作不易，如果对你有用，希望能点赞收藏支持一下。