C / C++ / 系统课时
TCP 为什么会出现粘包现象
TCP 为什么会出现粘包现象
所谓 TCP“粘包”不是 TCP 把数据包错误地粘在一起,而是应用把多次 send 当成了消息边界。TCP 只提供可靠、有序的字节流,一次 recv 可能读到半条、一条或多条应用消息。本节用实验说明这一点,并给出正确分帧方法。
学习目标
- 理解 TCP 字节流为什么没有
send与recv的一一对应关系 - 能解释“粘包”和“拆包”在应用层看到的现象
- 能用长度前缀等分帧规则恢复完整消息
TCP 只维护连续字节流
假设发送端连续调用两次 send,第一次交出 ABC,第二次交出 DEF。接收端看到的逻辑内容只是连续的六个字节 ABCDEF,TCP 不会额外保存“前三字节属于第一次调用”这样的元数据。
操作系统可能因为缓冲、调度、拥塞控制、分段与合并等因素,让接收端一次读到 6 字节,也可能先读到 2 字节再读到 4 字节。应用若直接把每次 recv 的返回当成一条完整消息,就会产生通常所说的“粘包”或“拆包”问题。

用一次实验看到边界消失
下面程序在本机回环地址建立真实 TCP 连接。子进程作为客户端连续发送 ABC 和 DEF,父进程作为服务器用一次 recv(..., MSG_WAITALL) 等待 6 个字节,因此会在一次接收调用里得到来自两次发送的连续内容。
#include <arpa/inet.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
static int send_all(int fd, const char *buf, size_t len) {
size_t sent = 0;
while (sent < len) {
ssize_t n = send(fd, buf + sent, len - sent, 0);
if (n > 0) {
sent += (size_t)n;
continue;
}
if (n < 0) {
if (errno == EINTR) {
continue;
}
return -1;
}
errno = EPIPE;
return -1;
}
return 0;
}
int main(void) {
int listener = socket(AF_INET, SOCK_STREAM, 0);
if (listener < 0) {
perror("socket");
return 1;
}
struct sockaddr_in addr = {0};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
addr.sin_port = htons(0);
if (bind(listener, (struct sockaddr *)&addr, sizeof(addr)) < 0 ||
listen(listener, 1) < 0) {
perror("bind/listen");
close(listener);
return 1;
}
socklen_t addr_len = sizeof(addr);
if (getsockname(listener, (struct sockaddr *)&addr, &addr_len) < 0) {
perror("getsockname");
close(listener);
return 1;
}
pid_t pid = fork();
if (pid < 0) {
perror("fork");
close(listener);
return 1;
}
if (pid == 0) {
int client = socket(AF_INET, SOCK_STREAM, 0);
if (client < 0) {
perror("socket");
_exit(1);
}
if (connect(client, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
perror("connect");
close(client);
_exit(1);
}
if (send_all(client, "ABC", 3) < 0 ||
send_all(client, "DEF", 3) < 0) {
perror("send");
close(client);
_exit(1);
}
close(client);
_exit(0);
}
int peer = accept(listener, NULL, NULL);
if (peer < 0) {
perror("accept");
close(listener);
return 1;
}
char buf[7] = {0};
ssize_t n = recv(peer, buf, 6, MSG_WAITALL);
if (n < 0) {
perror("recv");
close(peer);
close(listener);
return 1;
}
printf("one recv got %zd bytes: %.*s\n", n, (int)n, buf);
close(peer);
close(listener);
waitpid(pid, NULL, 0);
return 0;
}预期结果
one recv got 6 bytes: ABCDEF将代码保存为 tcp_stream_demo.c,然后编译并运行。
cc -Wall -Wextra -O2 tcp_stream_demo.c -o tcp_stream_demo
./tcp_stream_demo预期输出
one recv got 6 bytes: ABCDEF这个实验并不是说普通 recv 总会把两次 send 合并。MSG_WAITALL 只是让示例稳定地展示一个事实:TCP 接收端可以跨越发送调用边界读取连续字节,因此应用不能依赖这些边界来识别消息。
为什么不能靠 recv 次数分消息
即使发送端每次都发送固定字符串,接收端也可能遇到短读。一次 recv(fd, buf, 1024, 0) 返回 5,只说明当前拿到了 5 个字节;它并不表示第五个字节就是某条业务消息的结尾。
同样,禁用 Nagle 算法也不能解决消息边界问题。TCP_NODELAY 影响发送策略,不会让 TCP 获得“每次 send 是一条消息”的语义。真正的解决办法必须来自应用协议本身。
用协议定义消息边界
常见分帧方式有三类:固定长度、分隔符、长度前缀。固定长度适合字段尺寸稳定的数据;分隔符适合文本协议,但需要处理转义或禁止分隔符出现在正文中;长度前缀最通用,通常先发送固定宽度的消息长度,再发送对应字节数的正文。
采用 32 位网络字节序长度前缀时,接收端的逻辑应是:先精确读取 4 字节长度字段,用 ntohl 转成本机整数;检查长度是否超过协议上限;再循环 recv,直到累计得到完整正文。处理多个消息时,把这套过程重复执行,而不是把一次 recv 等同于一次消息。
下面是接收固定字节数的片段示例,依赖 <errno.h>、<sys/socket.h> 和一个已经建立连接的套接字 fd,可作为长度前缀协议的基础函数。
static ssize_t recv_exact(int fd, void *buf, size_t len) {
size_t used = 0;
while (used < len) {
ssize_t n = recv(fd, (char *)buf + used, len - used, 0);
if (n > 0) {
used += (size_t)n;
continue;
}
if (n == 0) {
return (ssize_t)used;
}
if (errno == EINTR) {
continue;
}
return -1;
}
return (ssize_t)used;
}这段代码本身不负责判断一条消息多长;它只保证“协议已经知道需要 N 字节时,持续读取直到够 N 字节、对端关闭或发生错误”。完整协议还必须限制最大消息长度,避免恶意长度值导致过度分配内存。
把 TCP 当成可靠有序的字节管道,再由应用协议自己定义消息边界,才能让接收逻辑在不同机器、不同负载和不同网络条件下保持正确。