一、先聊聊为什么要看重进程间通信
写分布式系统节点，说白了就是让一堆进程在不同的机器上跑，然后它们还得像一伙人似的互相配合。进程跟进程之间要传数据、要通知状态、要协调动作，这个"传话"的过程就是进程间通信（IPC）。你要是选错了通信方式，轻则性能拉垮，重则整个系统跑着跑着就散架了。所以，关于IPC的选型和实现细节，值得好好捋一捋。
二、应用场景：你手里的节点到底需要什么样的通信
2.1 节点间高频小数据的场景
比如你写了一个监控节点，每秒钟要上报一次CPU、内存这样的指标。这种数据量很小，但是频率很高。你要是用HTTP接口去POST，每次都要建立连接、封装HTTP头，开销其实挺大的。这种场景下，就可以考虑UDP或者一些轻量的消息队列。
2.2 节点间传输大文件的场景
比如一个节点要把训练好的模型文件传给另一个节点，文件可能有几百兆甚至几个G。这种场景你肯定不能用UDP一帧一帧地发，因为丢包了你得自己费劲去补。你会优先考虑TCP，或者干脆用现成的文件传输工具/对象存储，再把下载链接传给对方。
2.3 节点间要求强一致性的场景
比如多个节点在做分布式锁，或者要协调事务，那通信绝对不能丢消息，也不能乱序。这时候首选TCP，或者用带有确认机制的可靠消息队列。
三、技术选型：几种主流的进程间通信方式
3.1 TCP Socket：最朴实也最靠谱
TCP说白了就是打电话，你拨过去，对方接了，然后你一句我一句，双方都确认收到了才继续。优点就是可靠，不丢数据，不乱序。缺点就是需要处理粘包、半包，还得自己设计协议。但在分布式节点里，TCP的扎实是其他很多方案都替代不了的。
3.2 UDP Socket：图快但不保证送达
UDP就是发微信消息，你发出去了，但对方有没有看到你不知道，消息也可能乱序。它适合对实时性要求极高、能容忍偶尔丢数据的场景，比如心跳检测。你每秒钟发10个心跳，丢一个也无所谓，因为下一个马上就到。
3.3 Unix Domain Socket：同一个机器上最快的选择
如果你的两个节点进程跑在同一台Linux服务器上，那就没必要走网络协议栈了，直接用Unix Domain Socket（也就是本地socket）。它不走TCP/IP那一套，直接在内核里把数据拷来拷去，比TCP快很多，而且还不占网络端口。
3.4 消息队列：解耦又省心
消息队列（比如RabbitMQ、Kafka）就像是中间放了一个信箱，发信的节点把信放进去就行，收信的节点自己去取。好处是就算其中一个节点挂了，消息也会留在信箱里，等它恢复再取。这种方式适合节点之间不需要直接对话，而是通过异步解耦来协作的场景。
四、详细实现细节：拿TCP Socket来举例
我们这里用C语言来写一个非常典型的例子。技术栈是C语言 + POSIX Socket API。这个例子有两个程序：一个服务端节点，一个客户端节点。服务端监听5678端口，接收客户端传来的字符串，然后原样返回。
4.1 服务端节点的实现
// server.c —— TCP服务端节点
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#define PORT 5678 // 端口号
#define BUFFER_SIZE 1024 // 缓冲区大小
int main() {
// 1. 创建socket：AF_INET表示IPv4，SOCK_STREAM表示TCP流式传输
int server_fd = socket(AF_INET, SOCK_STREAM, 0);
if (server_fd < 0) {
perror("socket 创建失败");
exit(EXIT_FAILURE);
}
// 2. 设置地址复用，避免重启时端口被占用
int opt = 1;
setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
// 3. 绑定地址和端口
struct sockaddr_in server_addr;
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET; // IPv4
server_addr.sin_addr.s_addr = INADDR_ANY; // 监听所有网卡
server_addr.sin_port = htons(PORT); // 端口号转网络字节序
if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
perror("bind 失败");
close(server_fd);
exit(EXIT_FAILURE);
}
// 4. 开始监听，最大等待队列长度为5
if (listen(server_fd, 5) < 0) {
perror("listen 失败");
close(server_fd);
exit(EXIT_FAILURE);
}
printf("服务端节点已启动，等待客户端连接...\n");
// 5. 循环接受客户端连接
while (1) {
struct sockaddr_in client_addr;
socklen_t client_len = sizeof(client_addr);
int client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &client_len);
if (client_fd < 0) {
perror("accept 失败");
continue;
}
// 打印客户端IP和端口
char client_ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, sizeof(client_ip));
printf("收到来自 %s:%d 的连接\n", client_ip, ntohs(client_addr.sin_port));
// 6. 接收数据并回显
char buffer[BUFFER_SIZE];
ssize_t bytes_read;
while ((bytes_read = recv(client_fd, buffer, sizeof(buffer) - 1, 0)) > 0) {
buffer[bytes_read] = '\0'; // 手动补一个字符串结束符
printf("收到数据: %s", buffer);
// 原样返回给客户端
send(client_fd, buffer, bytes_read, 0);
memset(buffer, 0, sizeof(buffer)); // 清空缓冲区
}
close(client_fd); // 客户端断开后关闭连接
printf("客户端连接已关闭\n");
}
close(server_fd);
return 0;
}
4.2 客户端节点的实现
// client.c —— TCP客户端节点
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#define SERVER_IP "127.0.0.1" // 服务端地址，这里用本机测试
#define PORT 5678 // 端口号
#define BUFFER_SIZE 1024
int main() {
// 1. 创建socket
int sock_fd = socket(AF_INET, SOCK_STREAM, 0);
if (sock_fd < 0) {
perror("socket 创建失败");
exit(EXIT_FAILURE);
}
// 2. 设置服务端地址
struct sockaddr_in server_addr;
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT);
// 将点分十进制IP转换成二进制
if (inet_pton(AF_INET, SERVER_IP, &server_addr.sin_addr) <= 0) {
perror("IP地址转换失败");
close(sock_fd);
exit(EXIT_FAILURE);
}
// 3. 连接服务端
if (connect(sock_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
perror("连接服务端失败");
close(sock_fd);
exit(EXIT_FAILURE);
}
printf("已连接到服务端 %s:%d\n", SERVER_IP, PORT);
// 4. 发送数据并等待回显
const char* message = "Hello, 分布式节点!\n";
send(sock_fd, message, strlen(message), 0);
char buffer[BUFFER_SIZE];
ssize_t bytes_read = recv(sock_fd, buffer, sizeof(buffer) - 1, 0);
if (bytes_read > 0) {
buffer[bytes_read] = '\0';
printf("服务端回显: %s", buffer);
}
// 5. 关闭连接
close(sock_fd);
printf("连接已关闭\n");
return 0;
}
4.3 编译和运行
# 编译服务端
gcc server.c -o server
# 编译客户端
gcc client.c -o client
# 先运行服务端
./server
# 再开一个终端运行客户端
./client
跑起来之后，你会在客户端看到"服务端回显"，这就是一次完整的C语言进程间通信。
五、必须注意的坑：粘包与半包
用TCP的时候最常遇到的就是粘包和半包。因为TCP是流式协议，它不帮你划清消息的边界。比如你连续发了两次"hello"和"world"，接收方可能一次性收到"helloworld"，也可能先收到"hel"，再收到"loworld"。这在C语言里尤其要命，因为C语言没有Java那种现成的序列化框架。
解决方案有很多，最简单的一种是：定义自己的消息格式，比如"4字节长度+消息体"。发送方先算出消息体有多少个字节，把长度转成网络字节序发过去，再发消息体。接收方先读4个字节，解析出长度，再读对应长度的数据。这样就不会乱套了。下面给出一个简化版的做法。
// 发送一条带长度前缀的完整消息
void send_message(int fd, const char* data, int len) {
// 1. 先把len转成网络字节序（大端）
uint32_t net_len = htonl(len);
// 2. 一次性把长度和内容发出去
// 为了简单我们还是分两次send，实际开发中可以合并
if (send(fd, &net_len, sizeof(net_len), 0) != sizeof(net_len)) {
perror("发送长度失败");
return;
}
if (send(fd, data, len, 0) != len) {
perror("发送内容失败");
}
}
// 接收方读取一条完整消息，返回消息体长度
int recv_message(int fd, char* buffer, int buffer_size) {
uint32_t net_len;
// 1. 先读4个字节的长度
ssize_t n = recv(fd, &net_len, sizeof(net_len), 0);
if (n <= 0) return -1;
int len = ntohl(net_len); // 转回主机字节序
if (len <= 0 || len >= buffer_size) {
return -2; // 参数检查
}
// 2. 循环读取直到收满len个字节
// 注意：一次recv不一定能把len都读完，所以要循环
int received = 0;
while (received < len) {
n = recv(fd, buffer + received, len - received, 0);
if (n <= 0) return -1; // 连接断开
received += n;
}
buffer[received] = '\0'; // 补结束符
return received;
}
六、另一种常见选择：UDP用于心跳检测
节点之间常常用UDP做心跳，因为UDP不用建立连接，发一个包就完事了，功耗和开销都很低。下面是一个UDP发送端的小例子，用来每秒发送一次心跳包。
6.1 UDP心跳发送端
// udp_heartbeat_sender.c —— UDP心跳发送端
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#define TARGET_IP "192.168.1.10"
#define TARGET_PORT 9000
int main() {
// 1. 创建UDP socket
int fd = socket(AF_INET, SOCK_DGRAM, 0);
if (fd < 0) {
perror("socket 创建失败");
return 1;
}
// 2. 设置目标地址
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(TARGET_PORT);
inet_pton(AF_INET, TARGET_IP, &addr.sin_addr);
// 3. 循环发送心跳
char heartbeat[] = "ping";
while (1) {
sendto(fd, heartbeat, strlen(heartbeat), 0,
(struct sockaddr*)&addr, sizeof(addr));
printf("已发送心跳，目标：%s:%d\n", TARGET_IP, TARGET_PORT);
sleep(1); // 每秒一次
}
close(fd);
return 0;
}
6.2 UDP心跳接收端
// udp_heartbeat_receiver.c —— UDP心跳接收端
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#define BIND_PORT 9000
#define TIMEOUT_SEC 3
int main() {
int fd = socket(AF_INET, SOCK_DGRAM, 0);
if (fd < 0) {
perror("socket 创建失败");
return 1;
}
// 绑定端口
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(BIND_PORT);
addr.sin_addr.s_addr = INADDR_ANY;
bind(fd, (struct sockaddr*)&addr, sizeof(addr));
// 设置接收超时，3秒没收到心跳就认为对方可能掉线了
struct timeval tv;
tv.tv_sec = TIMEOUT_SEC;
tv.tv_usec = 0;
setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
char buffer[64];
struct sockaddr_in sender;
socklen_t sender_len = sizeof(sender);
while (1) {
memset(buffer, 0, sizeof(buffer));
ssize_t n = recvfrom(fd, buffer, sizeof(buffer) - 1, 0,
(struct sockaddr*)&sender, &sender_len);
if (n < 0) {
printf("超时未收到心跳，节点可能异常\n");
} else {
printf("收到心跳: %s\n", buffer);
}
}
close(fd);
return 0;
}
七、技术优缺点对比
| 通信方式 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| TCP Socket | 可靠、不丢包、不乱序、全双工 | 需要处理粘包/半包、连接管理复杂、相对慢 | 数据一致性要求高的任务，比如日志传输、任务分发 |
| UDP Socket | 简单、快、无连接、适合广播 | 丢包、乱序、无流量控制 | 心跳检测、实时监控、音视频流 |
| Unix Domain Socket | 比TCP快、不占网络端口、内核级传输 | 只能同机通信 | 同一台机器上的两个节点进程 |
| 消息队列 | 解耦、消息持久化、削峰填谷、无需自己处理重连 | 引入额外依赖、可能成为瓶颈、延迟稍高 | 异步任务、事件通知、跨语言通信 |
八、选型时候的几条实用建议
第一，先看两个节点是不是在同一台机器上。如果是，优先考虑Unix Domain Socket或者共享内存，性能会好不少。别一上来就甩一个TCP连接，白白浪费内存拷贝。
第二，看数据能不能丢。能容忍丢的，就用UDP；不能丢的，别碰UDP，老老实实TCP或者消息队列。
第三，看要不要异步。如果你的节点A发消息给B之后，不想一直等B的回音，那就可以用消息队列。这样把"发消息"和"处理消息"完全解耦，系统扩展起来也更方便。
第四，一定要自己做一下压力测试。比如你选了TCP，那就写个小脚本模拟一千个连接同时发数据，看看内存和CPU表现怎么样。很多坑只有压测才能逼出来。
九、文章总结
在C语言写分布式节点的世界里，进程间通信不是一个"随手选一个"的事情。TCP可靠但麻烦，UDP简单但不可靠，Unix Domain Socket快但有限制，消息队列省心但重。你需要从实际场景出发，搞清楚数据量、频率、可靠性、同机还是跨机这几个关键点，再做出决定。另外，只要用了TCP，粘包半包的问题就绕不开，一定要在协议设计上提前做好规划。代码只是实现的一部分，更多的功夫花在边界情况和容错处理上。C语言的表达虽然啰嗦，但它给出的控制力，恰恰是分布式系统底层最需要的东西。希望你读完这篇文章，再写自己的节点通信时，能少走一些弯路。好了，这篇文章就聊到这里，你可以打开编辑器，把你自己的第一个通信节点写出来了。
评论
围绕“C语言编写分布式系统节点时，进程间通信的技术选型与实现细节”参与讨论