爆肝整理!Linux/UNIX 进程间通信(IPC)方式图解

大家好，我是蟹老板～

搞后端、搞嵌入式、搞系统开发，只要你的程序跑在 Linux 上，迟早得面对面试官的一个灵魂拷问：你的进程之间怎么实现通信？

一个进程负责采集数据，一个进程负责存数据库；一个进程负责UI界面，一个进程负责后台计算；浏览器和渲染引擎要通信，Nginx和业务程序要通信，Docker里的服务和宿主机也要通信。

说白了，Linux系统表面上看是一堆进程同时运行，本质上其实就是：一群互相隔离的进程，想尽办法交换数据。

而解决这个问题的机制，就是IPC（Inter Process Communication，进程间通信）。

今天这一篇，我准备把 Linux/UNIX 里最核心、最常用、面试官最爱问、项目里必会的 IPC 方式，一次性给大家讲明白。

整理出来，不是为了方便大家背八股啊。

而是为了大家想在选型的时候，别一拍脑袋就用个 Socket 去传本机两个进程的几 KB 数据，毕竟，选错 IPC，加班调优火葬场。

看完这一篇，你基本就有数了。

一、管道类

Linux 最早的 IPC 方案就是管道。 本质上就是内核提供的一个环形缓冲区。它的设计哲学就是 "一切皆文件"，你可以把它理解成： 两个进程之间架了一根水管。一个只管写，一个只管读，数据走单行道。 简单粗暴。

1.1 匿名管道（Pipe）

匿名管道是最基础、最常用的父子进程通信方式。它的本质是半双工通信。

大白话来讲就是：数据只能单向流动，要么父写子读，要么子写父读，不能同时双向传输。而且匿名管道没有名字，只能在有亲缘关系的进程（父子、兄弟进程）之间使用，因为子进程会继承父进程打开的文件描述符。

最经典的例子：

ps aux | grep nginx

这里的|其实就是匿名管道，前面的进程输出数据，后面的进程接收数据，整个过程完全不需要临时文件。是不是很丝滑？

它的本质是在内核中开辟一块环形缓冲区，然后给你返回两个文件描述符：fd[0] 专门读，fd[1] 专门写。数据在管道里是无结构的字节流，单向流动，流完就没了，不能倒带，也不能重复读。使用时一定要记住：不需要的那一端必须关闭！不然会导致进程永远阻塞在 read 或者 write 上。

1.2 命名管道（FIFO）

匿名管道只能给亲戚用之痛，催生了命名管道（FIFO）。顾名思义，它有一个文件系统路径作为名字

它和匿名管道的内核机制一脉相承，也是字节流、单向的，但它有一个在文件系统中可见的文件名。这意味着，就算张三进程和李四进程八竿子打不着，只要它们知道这个文件路径（通常在 /tmp/ 下），就能通过 open() 打开它，然后开始读写通信。不需要亲缘关系，这是它最大的突破。

但注意，这个文件只是个“入口地址”，数据根本不落盘，还是走内存。

你可以用mkfifo命令创建一个命名管道：

mkfifo my_fifo

然后你会看到一个类型为p的特殊文件：

ls -l my_fifoprw-r--r-- 1 user user 0 Jun  8 10:00 my_fifo

任何进程，只要有权限，都可以打开这个文件进行读写。和匿名管道一样，FIFO默认也是半双工的，而且读写操作默认是阻塞的：如果一个进程以只读方式打开FIFO，它会一直阻塞到有另一个进程以只写方式打开同一个FIFO为止，反之亦然。

看一个简单的示例，一个进程写，另一个进程读：

写进程：

#include <stdio.h>#include <fcntl.h>#include <unistd.h>#include <string.h>int main() {    int fd = open("my_fifo", O_WRONLY);    if (fd == -1) {        perror("open");        return 1;    }    const char *msg = "Hello from writer!";    write(fd, msg, strlen(msg));    close(fd);    return 0;}

读进程：

#include <stdio.h>#include <fcntl.h>#include <unistd.h>int main() {    int fd = open("my_fifo", O_RDONLY);    if (fd == -1) {        perror("open");        return 1;    }    char buf[1024];    ssize_t n = read(fd, buf, sizeof(buf));    printf("读进程收到：%.*s\n", (int)n, buf);    close(fd);    return 0;}

FIFO的优点是可以在任意进程间通信，使用简单；缺点还是半双工，而且存在阻塞问题，性能一般，传输能力有限，大数据量场景基本不会考虑它。它适用于简单的、无亲缘关系的进程间通信，比如不同程序之间传递简单的指令。

二、信号类

信号（Signal）是整个 Linux/UNIX IPC 里面唯一的异步通信机制，也是最特殊的一种IPC。它不是用来传输大量数据的，而是用来通知进程发生了某个事件。

内核可以给进程发信号，进程也可以给另一个进程发信号。当进程收到信号时，它可以有三种处理方式：

1. 1. 默认处理：大多数信号的默认处理是终止进程
2. 2. 忽略信号：进程会假装没收到这个信号（SIGKILL和SIGSTOP不能被忽略）
3. 3. 自定义处理：执行我们自己写的信号处理函数

常见的信号有：

• • SIGINT：用户按下Ctrl+C时发送，默认终止进程
• • SIGTERM：系统发送的终止信号，可以被捕获和处理
• • SIGKILL：强制终止信号，不能被捕获或忽略
• • SIGCHLD：子进程退出时发送给父进程
• • SIGUSR1/SIGUSR2：用户自定义信号，用于进程间通信

很多人喜欢用signal()函数来注册信号处理函数，但我强烈建议你们用sigaction()！因为signal()在不同UNIX系统上的行为不一致，而且在处理信号时会自动重置信号处理函数为默认值，容易导致竞态条件。

来看个用sigaction()注册SIGINT处理函数的示例：

#include <stdio.h>#include <signal.h>#include <unistd.h>void sigint_handler(int sig) {    printf("\n收到SIGINT信号，程序即将退出\n");    // 注意：信号处理函数里只能调用异步安全的函数！    // 绝对不能调用printf、malloc、free这些非异步安全的函数！    // 这里只是演示，实际项目中不要这么做！    _exit(0); // 用_exit而不是exit，因为exit会刷新缓冲区}int main() {struct sigaction sa;    sa.sa_handler = sigint_handler;    sigemptyset(&sa.sa_mask);    sa.sa_flags = 0;    if (sigaction(SIGINT, &sa, NULL) == -1) {        perror("sigaction");        return 1;    }    printf("程序运行中，按Ctrl+C退出\n");    while (1) {        sleep(1);    }    return 0;}

这里有个很坑的点：信号处理函数里只能调用异步安全的函数！就是这个函数在执行过程中被信号中断，再次进入也不会出问题。像printf、malloc、free、fopen这些函数都不是异步安全的，在信号处理函数里调用它们会导致不可预知的后果，轻则程序崩溃，重则数据损坏。

信号的优点是轻量级、异步通知；缺点是只能传递简单的信号编号，不能传递复杂数据，而且信号处理函数有很多限制。它主要用于进程间的事件通知，比如父进程等待子进程退出、进程收到终止信号时做清理工作。

三、POSIX IPC系列

POSIX IPC是IEEE标准化的进程间通信接口，包括消息队列、共享内存和信号量三种。相比于古老的System V IPC，POSIX IPC接口更简洁、更易用，是现代Linux编程的主流。

3.1 消息队列（mq_open/mq_send）

消息队列是一种基于消息的通信方式，它解决了管道"无边界数据流"的问题。在管道里，数据是一串连续的字节流，你不知道一条消息从哪里开始，到哪里结束；而在消息队列里，数据是以独立的消息为单位传输的，每个消息有自己的类型和长度。

消息队列由内核维护，进程退出后消息仍然存在，直到被其他进程读取或者队列被删除。它支持随机读取，你可以指定读取特定类型的消息，而不用按照先进先出的顺序。

基本操作函数：

• • mq_open()：创建或打开一个消息队列
• • mq_send()：发送一条消息
• • mq_receive()：接收一条消息
• • mq_close()：关闭消息队列
• • mq_unlink()：删除消息队列

我们来看一个简单的消息队列示例：

发送端：

#include <stdio.h>#include <fcntl.h>#include <mqueue.h>#include <string.h>#define QUEUE_NAME "/my_queue"#define MAX_MSG_SIZE 1024int main() {    // 打开消息队列，O_CREAT表示不存在则创建，0666是权限    mqd_t mq = mq_open(QUEUE_NAME, O_WRONLY | O_CREAT, 0666, NULL);    if (mq == (mqd_t)-1) {        perror("mq_open");        return 1;    }    const char *msg = "Hello from message queue!";    // 发送消息，优先级为0    if (mq_send(mq, msg, strlen(msg), 0) == -1) {        perror("mq_send");        return 1;    }    printf("消息发送成功\n");    mq_close(mq);    return 0;}

接收端：

#include <stdio.h>#include <fcntl.h>#include <mqueue.h>#define QUEUE_NAME "/my_queue"#define MAX_MSG_SIZE 1024int main() {    mqd_t mq = mq_open(QUEUE_NAME, O_RDONLY);    if (mq == (mqd_t)-1) {        perror("mq_open");        return 1;    }    char buf[MAX_MSG_SIZE];    unsigned int prio;    // 接收消息    ssize_t n = mq_receive(mq, buf, MAX_MSG_SIZE, &prio);    if (n == -1) {        perror("mq_receive");        return 1;    }    printf("收到消息（优先级%d）：%.*s\n", prio, (int)n, buf);    mq_close(mq);    // 用完记得删除消息队列，否则会一直存在于系统中    mq_unlink(QUEUE_NAME);    return 0;}

编译的时候记得加-lrt链接实时库：

gcc sender.c -o sender -lrtgcc receiver.c -o receiver -lrt

消息队列的优点是有消息边界、支持优先级、支持随机读取、内核维护；缺点是消息大小有限制（Linux默认最大8KB）、不适合传输大量数据。它适用于传递小消息、需要按优先级处理的场景，比如任务调度、事件通知。

3.2 共享内存（shm_open + mmap）

共享内存是 Linux 下所有 IPC 的性能天花板，没有之一，单机数据交换的唯一真神。

内核分配一块物理内存，然后多个进程通过mmap()把这块内存映射到自己的虚拟地址空间，数据不需要在内核和用户空间之间拷贝，直接在用户空间就能读写。这样，一个进程对这块内存的修改，其他进程能立刻看到。完全避免了内核作为中间商的拷贝开销。零拷贝，极致的快。数据库的 Buffer Pool 共享、音视频流的高效传输，底层全是这玩意儿。

但“快”也意味着“乱”，共享内存它本身不提供任何同步机制**！多个进程同时往白板上写字，很容易把字写重叠（竞争条件）。所以，用共享内存几乎必然**要搭配“互斥锁”或者“信号量”来维持秩序。

基本操作步骤：

1. 1. shm_open()：创建或打开一个共享内存对象
2. 2. ftruncate()：设置共享内存的大小
3. 3. mmap()：将共享内存映射到进程地址空间
4. 4. 读写共享内存
5. 5. munmap()：解除映射
6. 6. close()：关闭共享内存对象
7. 7. shm_unlink()：删除共享内存对象

一起来看一个简单的共享内存示例，两个进程共享一个整数：

写进程：

#include <stdio.h>#include <fcntl.h>#include <sys/mman.h>#include <unistd.h>#include <string.h>#define SHM_NAME "/my_shm"#define SHM_SIZE sizeof(int)int main() {    // 创建共享内存对象    int fd = shm_open(SHM_NAME, O_RDWR | O_CREAT, 0666);    if (fd == -1) {        perror("shm_open");        return 1;    }    // 设置共享内存大小    if (ftruncate(fd, SHM_SIZE) == -1) {        perror("ftruncate");        return 1;    }    // 映射到进程地址空间    int *shared_int = mmap(NULL, SHM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);    if (shared_int == MAP_FAILED) {        perror("mmap");        return 1;    }    close(fd); // 映射完成后就可以关闭文件描述符了    // 写入数据    *shared_int = 42;    printf("写入数据：%d\n", *shared_int);    // 等待读进程读取    sleep(5);    // 解除映射    munmap(shared_int, SHM_SIZE);    // 删除共享内存对象    shm_unlink(SHM_NAME);    return 0;}

读进程：

#include <stdio.h>#include <fcntl.h>#include <sys/mman.h>#include <unistd.h>#define SHM_NAME "/my_shm"#define SHM_SIZE sizeof(int)int main() {    // 打开共享内存对象    int fd = shm_open(SHM_NAME, O_RDONLY, 0666);    if (fd == -1) {        perror("shm_open");        return 1;    }    // 映射到进程地址空间    int *shared_int = mmap(NULL, SHM_SIZE, PROT_READ, MAP_SHARED, fd, 0);    if (shared_int == MAP_FAILED) {        perror("mmap");        return 1;    }    close(fd);    // 读取数据    printf("读取数据：%d\n", *shared_int);    // 解除映射    munmap(shared_int, SHM_SIZE);    return 0;}

同样，编译的时候要加-lrt。

共享内存的优点是速度极快、适合传输大量数据；缺点是没有同步机制、容易产生竞态条件、调试困难。它是大数据量传输（比如图像处理、数据库缓存）的首选，但编程复杂度也是最高的，比如视频处理、数据库、高频交易系统。

3.3 信号量（sem_open）

注意了，我们这里聊的是 POSIX 命名信号量，很多人容易把信号量和前面的“信号”搞混，记住：它们俩半毛钱关系都没有！

信号量（sem_open）不是用来传数据的，它是**“交通警察”。本质上就是一个内核计数器**，专门用来做进程间的同步和互斥。它最经典的操作就是 P操作（进入，计数器减1） 和 V操作（退出，计数器加1）。

当计数器的值为 1 的时候，它就是一把分布式锁。共享内存要想安全用，必须让信号量在旁边站岗：

// 伪代码：共享内存加锁的标准姿势sem_wait(sem); // P操作，抢锁。抢不到就憋着memcpy(shm_ptr, data, size); // 写入共享内存sem_post(sem); // V操作，释放锁。后面排队的进程可以进来了

如果没有这层保护，在多核 CPU 高并发下，你的共享内存分分钟变成车祸现场。

四、套接字类

套接字（Socket）是最通用的IPC方式，它不仅可以用于同一台主机上的进程间通信，还可以用于不同主机上的进程间通信。

4.1 UNIX Domain Socket

很多人以为Socket就是网络通信，其实不完全对。

UNIX Domain Socket：这是本机进程通信的六边形战士，我个人最推荐的万能方案。虽然它用的是网络协议的编程接口（API），但传输层走的是操作系统内核，而不是网卡。

像MySQL、Nginx这些本地服务的高性能通信，很多都用的是UNIX域套接字。

它有两种类型：

• • SOCK_STREAM：流套接字，类似TCP，可靠、有序、面向连接
• • SOCK_DGRAM：数据报套接字，类似UDP，不可靠、无连接

UNIX Domain Socket通过文件系统路径来标识，支持权限控制，可以设置只有特定用户的进程才能访问。

一个简单的UNIX Domain Socket流套接字示例：

服务端：

#include <stdio.h>#include <sys/socket.h>#include <sys/un.h>#include <unistd.h>#include <string.h>#define SOCKET_PATH "/tmp/my_unix_socket"#define BUF_SIZE 1024int main() {    int server_fd, client_fd;struct sockaddr_un server_addr, client_addr;    socklen_t client_len = sizeof(client_addr);    char buf[BUF_SIZE];    // 创建UNIX域流套接字    server_fd = socket(AF_UNIX, SOCK_STREAM, 0);    if (server_fd == -1) {        perror("socket");        return 1;    }    // 如果socket文件已经存在，先删除    unlink(SOCKET_PATH);    // 绑定地址    memset(&server_addr, 0, sizeof(server_addr));    server_addr.sun_family = AF_UNIX;    strncpy(server_addr.sun_path, SOCKET_PATH, sizeof(server_addr.sun_path) - 1);    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {        perror("bind");        return 1;    }    // 监听    if (listen(server_fd, 5) == -1) {        perror("listen");        return 1;    }    printf("服务端等待连接...\n");    // 接受连接    client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_len);    if (client_fd == -1) {        perror("accept");        return 1;    }    printf("客户端已连接\n");    // 接收数据    ssize_t n = read(client_fd, buf, BUF_SIZE);    printf("收到：%.*s\n", (int)n, buf);    // 发送响应    const char *response = "Hello from server!";    write(client_fd, response, strlen(response));    close(client_fd);    close(server_fd);    unlink(SOCKET_PATH);    return 0;}

客户端：

#include <stdio.h>#include <sys/socket.h>#include <sys/un.h>#include <unistd.h>#include <string.h>#define SOCKET_PATH "/tmp/my_unix_socket"#define BUF_SIZE 1024int main() {    int sockfd;struct sockaddr_un server_addr;    char buf[BUF_SIZE];    // 创建套接字    sockfd = socket(AF_UNIX, SOCK_STREAM, 0);    if (sockfd == -1) {        perror("socket");        return 1;    }    // 连接服务端    memset(&server_addr, 0, sizeof(server_addr));    server_addr.sun_family = AF_UNIX;    strncpy(server_addr.sun_path, SOCKET_PATH, sizeof(server_addr.sun_path) - 1);    if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {        perror("connect");        return 1;    }    // 发送数据    const char *msg = "Hello from client!";    write(sockfd, msg, strlen(msg));    // 接收响应    ssize_t n = read(sockfd, buf, BUF_SIZE);    printf("收到响应：%.*s\n", (int)n, buf);    close(sockfd);    return 0;}

UNIX Domain Socket的优点是效率高、可靠、支持全双工、支持权限控制；缺点是只能在同一台主机上使用。它是同一主机上复杂进程间通信的首选，比如Web服务器和应用服务器之间的通信、数据库客户端和服务器之间的通信。

4.2 网络 Socket

这个大家最熟了，跨主机通信的绝对标准，互联网的基石。AF_INET + TCP/UDP。用于不同主机上的进程间通信。

把它也放在 IPC 里，是因为很多时候我们用它来做本机进程间的通信（127.0.0.1 环回地址）。而且开发调试非常方便，将来把服务拆到多台机器上，代码基本不用改。

它有两种主要类型：

• • TCP：面向连接、可靠、有序、字节流
• • UDP：无连接、不可靠、数据报

网络Socket的编程接口和UNIX Domain Socket几乎一样，只是地址结构不同。TCP需要三次握手建立连接，四次挥手断开连接，提供可靠的数据传输；UDP不需要建立连接，速度快，但可能丢包、乱序。

网络Socket的优点是跨主机、通用性强、支持全双工；缺点是有网络开销、开发调试复杂。它是分布式系统、网络应用的基础。

五、高级封装组件

上面讲的都是Linux内核提供的原生IPC方式，它们功能强大但接口比较底层，在复杂项目中，直接用裸的共享内存加信号量，开发效率低不说，还容易出 bug。

接下来的这些它们是封装了上面那些底层协议的高级封装组件。，它们提供了更友好的接口、更丰富的功能，能大大提高开发效率。

当你不想自己造轮子的时候，这些东西就香了。

5.1 D-Bus

这是 Linux 桌面环境的消息总线，IPC 的中央调度中心，

在 Linux 桌面环境（比如 Ubuntu 的 GNOME/KDE）或者汽车车载系统（AGL、GENIVI）里，D-Bus 是绝对的统治者。

它不是一个简单的协议，而是一个总线系统。它支持信号订阅（Publish/Subscribe）和远程方法调用（RPC）。

一个进程往 D-Bus 总线上丢一个广播，所有关注这个事件的进程都能收到，非常适合用来做复杂的系统级状态管理（比如：电池电量低了，通知屏幕变暗、通知电源管理进程进低功耗、通知UI弹窗）。但由于它层层封装，性能相对比较弱，不适合传海量大数据。

5.2 gRPC/Thrift

如果你在搞分布式微服务，或者嵌入式设备需要跟云端、上位机进行复杂的结构化业务交互，Socket已经不够用了，直接上 gRPC（谷歌出品）或者 Thrift（Apache出品）。

它们是标准的 RPC（远程过程调用）框架。底层基于 HTTP/2（gRPC）或者自研高效传输协议，数据用 Protocol Buffers 等格式压缩，体积小、速度快，而且自带强类型定义，自动生成多语言代码。你像调用本地函数一样去调用另一个进程的函数就行，完全不需要自己去解析字节流。

gRPC使用Protocol Buffers作为序列化格式，支持多种编程语言，性能优异，是现在微服务架构的首选。Thrift是Facebook开发的，功能类似，也被广泛使用。

它们适用于跨语言、跨主机的进程间通信，特别是微服务架构中的服务调用。

5.3 ZeroMQ、MQTT

ZeroMQ和MQTT是消息传递和消息队列框架，它们提供了更高级的通信模式，简化了分布式系统的开发。

ZeroMQ 可以理解为 Socket 的超级增强版，一个高性能异步消息库。它不是中间件，而是一个库。你把它嵌入到程序里，它能用极简的代码实现复杂的消息模式（请求-应答、发布-订阅、推-拉），底层可以跑在 TCP、IPC 甚至内存里。性能极高，但需要学习它那套“无 broker”的思维模式。

MQTT是一个轻量级的发布-订阅消息协议，它天生是为低带宽、不可靠网络设计的，发布/订阅模式，心跳保活，QoS 控制。一个在火星上跑的机器人，和一个在地球上的控制中心，它们之间用 MQTT 传控制和遥测数据，就比用 TCP 裸协议要可靠得多，也省电得多。智能家居、工业物联网、车联网基本绕不开MQTT。

六、IPC 选型

我的经验是：

• • 父子进程通信 → Pipe
• • 简单通知 → Signal
• • 多任务调度 → Message Queue
• • 高频大数据 → Shared Memory
• • 本机服务通信 → UNIX Socket
• • 网络服务 → TCP Socket
• • Linux桌面开发 → D-Bus
• • 微服务 → gRPC
• • 物联网 → MQTT