4. 拆包现象演示：数据被拆成多个包接收

上一章我们聊了粘包，这次来聊聊它的「亲兄弟」——拆包。说白了，拆包就是发送方一次发送的数据，被 TCP 拆成了好几个小包，接收方得收好几次才能拼完整。

我在项目中遇到过好几次这种情况。有一次做视频流传输，客户端收到的画面总是花屏，查了半天才发现是拆包导致帧数据不完整。嗯，从那以后我对拆包就特别敏感。

4.1 为什么会发生拆包？

你想想看，TCP 是流式协议，它不关心你应用层怎么划分消息。它只按自己的节奏来：

• MSS（最大报文段长度）限制：TCP 每次能发送的数据段有上限。如果应用层数据超过 MSS，就必须拆成多个段发送。
• 发送缓冲区大小：发送缓冲区满了，剩下的数据就得等下一轮。
• 接收方窗口大小：接收方来不及处理，窗口变小，发送方就得少发点。
• Nagle 算法：这个算法会把小数据合并，但也可能把大数据拆开。

4.2 拆包演示代码

我写了一个简单的 demo，让你亲眼看到拆包是怎么发生的。服务端每次发送 10000 字节，但客户端每次只读 1024 字节。

先看服务端代码：

// server.c - 发送大数据
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT 8888
#define DATA_SIZE 10000

int main() {
    int server_fd, client_fd;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);
    char *buffer = malloc(DATA_SIZE);
    
    // 填充数据，方便观察
    memset(buffer, 'A', DATA_SIZE);
    
    // 创建 socket
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);
    
    bind(server_fd, (struct sockaddr *)&address, sizeof(address));
    listen(server_fd, 3);
    
    printf("服务端启动，等待连接...\n");
    client_fd = accept(server_fd, (struct sockaddr *)&address, 
                       (socklen_t*)&addrlen);
    
    printf("客户端已连接，发送 %d 字节数据...\n", DATA_SIZE);
    
    // 一次性发送所有数据
    int sent = send(client_fd, buffer, DATA_SIZE, 0);
    printf("实际发送: %d 字节\n", sent);
    
    // 等待一会，让客户端收完
    sleep(2);
    
    close(client_fd);
    close(server_fd);
    free(buffer);
    return 0;
}

再看客户端代码，关键在每次只读 1024 字节：

// client.c - 小缓冲区接收
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 8888
#define BUFFER_SIZE 1024

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char buffer[BUFFER_SIZE] = {0};
    int total_received = 0;
    int recv_count = 0;
    
    sock = socket(AF_INET, SOCK_STREAM, 0);
    
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);
    inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr);
    
    connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    
    printf("客户端已连接，开始接收数据...\n");
    printf("每次读取 %d 字节\n\n", BUFFER_SIZE);
    
    while (1) {
        int bytes = read(sock, buffer, BUFFER_SIZE);
        if (bytes <= 0) {
            break;
        }
        recv_count++;
        total_received += bytes;
        printf("第 %d 次接收: %d 字节 (累计: %d)\n", 
               recv_count, bytes, total_received);
    }
    
    printf("\n接收完成！\n");
    printf("总共接收: %d 次\n", recv_count);
    printf("总字节数: %d\n", total_received);
    
    close(sock);
    return 0;
}

4.3 运行结果分析

编译运行后，你会看到类似这样的输出：

客户端已连接，开始接收数据...
每次读取 1024 字节

第 1 次接收: 1024 字节 (累计: 1024)
第 2 次接收: 1024 字节 (累计: 2048)
第 3 次接收: 1024 字节 (累计: 3072)
...
第 9 次接收: 1024 字节 (累计: 9216)
第 10 次接收: 784 字节 (累计: 10000)

接收完成！
总共接收: 10 次
总字节数: 10000

看到了吗？发送方一次 send 了 10000 字节，但接收方分了 10 次才收完。前 9 次每次 1024 字节，最后一次 784 字节。

4.4 拆包 vs 粘包：一张图看懂

我画了一张对比图，帮你理清这两个概念：

4.5 拆包带来的问题

拆包本身不是问题，问题在于接收方不知道「消息边界」在哪。举个例子：

• 你发送了一条完整的 JSON 消息：{"cmd":"login","user":"admin"}
• 接收方第一次收到：{"cmd":"logi
• 第二次收到：n","user":"admin"}

如果直接解析，第一次收到的数据就是无效的 JSON。这就是拆包导致的「消息不完整」问题。

4.6 如何判断拆包发生了？

在实际开发中，你可以通过以下迹象判断拆包：

现象	可能原因	排查方法
recv() 返回值小于期望值	数据被拆包，还没收完	循环接收直到收满
解析协议时出现不完整数据	消息边界被拆开	检查消息长度字段
高并发下数据错乱	多个消息被拆包后交错	使用消息队列缓冲
recv() 返回 0 但数据没完	对端关闭连接	检查连接状态

4.7 拆包演示的完整流程

我把整个拆包过程总结成了一张流程图：

4.8 小结

拆包演示让我们看清了一个事实：TCP 不保证应用层消息的完整性。发送方一次 send，接收方可能需要多次 recv 才能收完。

我个人习惯在写网络程序时，永远假设数据会被拆包。这样写出来的代码才健壮。下一章我们会深入讨论如何解决拆包问题——也就是「消息边界」的确定方法。