3、粘包拆包问题复现：动手模拟数据边界丢失

说实话，很多初学者学网络编程时，都卡在粘包拆包这个问题上。我记得自己刚接触 socket 时，写了个简单的客户端和服务端，结果发出去的数据总是对不上。明明发了 3 条消息，服务端却只收到 2 条，或者一条消息被切成了两半。

为什么会这样？说白了，TCP 是流式协议。它不关心你发的是几条消息，它只负责把字节流从 A 点搬到 B 点。数据到了接收端，就像水流进了水池，你根本分不清哪滴水是哪次倒进去的。

这一章，我们就亲手复现这两个现象。你跟着我写一遍代码，感受一下什么叫「数据边界丢失」。

3.1 粘包现象模拟

粘包，就是多个数据包粘在一起。比如客户端连续发了 3 次 "Hello"，服务端一次就读到了 "HelloHelloHello"。

我项目中遇到过最典型的场景：一个游戏服务器，客户端上报玩家操作，每次操作都是一个独立的数据包。结果服务端收数据时，经常把两次操作粘在一起解析，导致逻辑直接崩了。

下面这个例子，模拟的就是粘包现象：

# server.py - 粘包模拟服务端
import socket

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('127.0.0.1', 8888))
server.listen(5)
print('服务端启动，等待连接...')

conn, addr = server.accept()
print(f'客户端已连接：{addr}')

# 只调用一次 recv，但客户端发了多次
data = conn.recv(1024)
print(f'服务端一次收到的数据：{data}')
print(f'数据长度：{len(data)} 字节')

conn.close()
server.close()

# client.py - 粘包模拟客户端
import socket
import time

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8888))

# 连续发送 3 条消息，中间不等待
client.send(b'Hello')
client.send(b'World')
client.send(b'Python')

print('客户端已发送 3 条消息')
time.sleep(1)
client.close()

3.2 拆包现象模拟

拆包正好相反。一条完整的消息，被 TCP 拆成了多个片段。比如你发了一个 1000 字节的数据包，服务端第一次 recv 只读到 300 字节，第二次读到 700 字节。

为什么会拆包？因为 TCP 的 MSS（最大报文段长度）限制了单个报文能携带的数据量。如果应用层数据包太大，IP 层就会分片，接收端再重组。但重组是在内核完成的，应用层感知不到——除非你 recv 的时机不对。

嗯，这里要注意：拆包现象在局域网里不太常见，但在公网上非常频繁。我曾经调试过一个跨省传输的日志系统，10 次里有 8 次数据被拆开。

来看代码：

# server_split.py - 拆包模拟服务端
import socket

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('127.0.0.1', 8889))
server.listen(5)
print('服务端启动，等待连接...')

conn, addr = server.accept()
print(f'客户端已连接：{addr}')

# 故意用很小的缓冲区 recv，模拟拆包
data1 = conn.recv(4)
print(f'第一次 recv 收到的数据：{data1}')

data2 = conn.recv(4)
print(f'第二次 recv 收到的数据：{data2}')

data3 = conn.recv(4)
print(f'第三次 recv 收到的数据：{data3}')

conn.close()
server.close()

# client_split.py - 拆包模拟客户端
import socket

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8889))

# 发送一条完整的长消息
message = b'HelloWorldPython'
print(f'客户端发送完整消息：{message}')
print(f'消息长度：{len(message)} 字节')
client.send(message)

client.close()

3.3 数据边界丢失的本质

你想想看，粘包和拆包，本质上是一个问题：TCP 不保留消息边界。

什么叫消息边界？就是你发了一条消息，接收方应该能明确知道「这条消息从哪开始、到哪结束」。但 TCP 不提供这个能力。它只保证字节的顺序和可靠性，不保证你一次 send 对应一次 recv。

我用一张图来说明：

从这张图可以看得很清楚：发送端明明发了 3 条独立的消息，但到了 TCP 流里，它们就混在一起了。接收端 recv 的时候，可能一次全读走（粘包），也可能读了一部分（拆包）。

3.4 动手验证：观察数据丢失

最后，我们写一个更真实的例子。客户端发送 10 条消息，服务端用循环 recv 接收，看看最终能收到几条完整消息：

# test_boundary.py - 边界丢失验证
import socket
import threading
import time

def server_thread():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind(('127.0.0.1', 8890))
    server.listen(1)
    conn, addr = server.accept()
    
    received_count = 0
    buffer = b''
    while True:
        data = conn.recv(1024)
        if not data:
            break
        buffer += data
        # 假设每条消息固定 10 字节
        while len(buffer) >= 10:
            msg = buffer[:10]
            buffer = buffer[10:]
            received_count += 1
            print(f'收到第 {received_count} 条消息：{msg}')
    
    print(f'\n总共收到 {received_count} 条完整消息')
    conn.close()
    server.close()

def client_thread():
    time.sleep(0.5)
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect(('127.0.0.1', 8890))
    
    for i in range(10):
        msg = f'Msg-{i:03d}---'.encode()  # 固定 10 字节
        client.send(msg)
        print(f'发送第 {i+1} 条消息：{msg}')
    
    time.sleep(1)
    client.close()

t1 = threading.Thread(target=server_thread)
t2 = threading.Thread(target=client_thread)
t1.start()
t2.start()
t1.join()
t2.join()

好了，粘包拆包的复现就到这里。你现在应该能直观感受到：TCP 流式传输确实不保留消息边界。下一章，我们会讨论如何用「消息定界法」来解决这个问题。

可可精品资料库