C / C++ / 系统课时

TCP 为什么会出现粘包现象

TCP 为什么会出现粘包现象

所谓 TCP“粘包”不是 TCP 把数据包错误地粘在一起,而是应用把多次 send 当成了消息边界。TCP 只提供可靠、有序的字节流,一次 recv 可能读到半条、一条或多条应用消息。本节用实验说明这一点,并给出正确分帧方法。

学习目标

  • 理解 TCP 字节流为什么没有 send 与 recv 的一一对应关系
  • 能解释“粘包”和“拆包”在应用层看到的现象
  • 能用长度前缀等分帧规则恢复完整消息

TCP 只维护连续字节流

假设发送端连续调用两次 send,第一次交出 ABC,第二次交出 DEF。接收端看到的逻辑内容只是连续的六个字节 ABCDEF,TCP 不会额外保存“前三字节属于第一次调用”这样的元数据。

操作系统可能因为缓冲、调度、拥塞控制、分段与合并等因素,让接收端一次读到 6 字节,也可能先读到 2 字节再读到 4 字节。应用若直接把每次 recv 的返回当成一条完整消息,就会产生通常所说的“粘包”或“拆包”问题。

TCP 字节流与应用消息边界关系

用一次实验看到边界消失

下面程序在本机回环地址建立真实 TCP 连接。子进程作为客户端连续发送 ABC 和 DEF,父进程作为服务器用一次 recv(..., MSG_WAITALL) 等待 6 个字节,因此会在一次接收调用里得到来自两次发送的连续内容。

c
#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;
}

预期结果

text
one recv got 6 bytes: ABCDEF

将代码保存为 tcp_stream_demo.c,然后编译并运行。

bash
cc -Wall -Wextra -O2 tcp_stream_demo.c -o tcp_stream_demo
./tcp_stream_demo

预期输出

text
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,可作为长度前缀协议的基础函数。

c
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 当成可靠有序的字节管道,再由应用协议自己定义消息边界,才能让接收逻辑在不同机器、不同负载和不同网络条件下保持正确。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

TCP 为什么会出现粘包现象

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通