第一次遇到「粘包」是在一个网关程序里。上位机通过 TCP 连设备,代码写得很顺:recv 一次,拿到的字节就是一帧,直接解析。测试时没问题,因为设备一次只发一帧,间隔也够长。上线后设备改成连续上报,一次 recv 经常读到两帧半,代码从第二帧的中间开始解析,后面每一帧都错位,日志里全是校验失败。

当时第一反应是「TCP 怎么把包粘在一起了」。查了半天才明白,TCP 从来没承诺「一次 recv 等于一条消息」。它保证字节按顺序到达、不丢不重,但一次读多少,取决于发送节奏、内核缓冲和程序调度。发送方连着写三次,接收方一次读出来,完全正常。

换到串口上也一样。UART 按字节到达,驱动缓冲区攒够了才交给应用,一次读到半帧或者三帧都不奇怪。所以「粘包」不是某种协议的缺陷,而是所有字节流链路的默认状态。真正要做的,是让解析器接受「一次读到的不一定是一帧」。

这篇用 Python 把同一段两帧数据切成不同大小的碎片,逐片喂给解析器,看它什么时候成帧、什么时候留半帧、什么时候丢垃圾。代码在本机 Python 3.15.0 上跑,输出原样贴出。真实串口的读取时序和驱动行为未在本机实测,文中只讨论字节层逻辑。

粘包和分包,本质是同一个问题

粘包指的是「多条消息粘在一起,一次读出来」。分包指的是「一条消息被切成几段,分几次才读完」。两者看起来相反,根子是同一件事:链路传的是字节流,不是一条条带边界的消息。

字节流(byte stream)的意思是,链路只保证字节的顺序,不保证「这一批字节属于同一条消息」。发送方写入的三个帧,在链路上就是一串连续的字节;接收方读到哪一段,和消息边界没有关系。

所以「粘包怎么解决」这个问题本身就问偏了。正确的问法是:接收端怎么从一串字节里,稳定地切出完整的帧。这个能力不依赖链路,靠的是协议里的帧头、长度、校验,以及接收端自己的缓冲。

还有一类「分包」是应用层故意的:一个大文件被切成多个数据块传输。这和链路层的分包不是一回事,前者是协议设计,后者是读取时机。两者都要求接收端有「拼起来再处理」的能力。

有人把「粘包」当成 TCP 的缺陷,是因为在应用层看,发送方的三次写入对应接收方的两次读取,好像消息被合并了。其实 TCP 只负责字节,消息边界是应用协议没定义清楚。换 UDP 也不会更好:UDP 保边界,但会丢包、乱序、重复,问题换了一种形式。

TCP 和串口,表现有什么不同

TCP 是可靠的字节流。它保证不丢、不重、按序,但一次 recv 返回多少字节,取决于内核缓冲区里当时有多少。发送方连发两帧,接收方可能一次拿到两帧,也可能先拿到半帧,过几毫秒再拿到剩下的。

串口是更原始的字节流。没有重传,没有确认,波特率决定每个字节的到达间隔;驱动通常有一个接收缓冲,攒到一定数量或者超时才交给应用。所以串口上「一次读到半帧」比 TCP 更常见,尤其是在低波特率、长帧的情况下。

两种链路的差别在可靠性,不在边界。TCP 会重传丢失的段,串口不会;但两者都不保证「一次读一条消息」。所以解析器的写法可以共用:缓冲、找帧头、按长度取帧、校验、交付。

有一个细节要注意:TCP 的「粘包」有时是因为发送方用了 send 小包合并(Nagle 算法),有时是因为接收方读得慢。这些都不该由应用去猜,应用只该按协议切帧。猜发送方的节奏,迟早会猜错。

实际调试时,可以在接收端打印每次读到的字节数和缓冲区长度。如果字节数忽大忽小、缓冲区经常超过一帧,基本就能确认「一次一帧」的假设不成立。这个日志比抓包更直接,因为它展示的是应用真正拿到的东西。

一个能处理任意分片的解析器

解析器的结构可以用四步概括:收进来的字节先追加到缓冲区;在缓冲区里找帧头;找到后按长度字段判断够不够一帧;够了就校验、交付、从缓冲区删掉,不够就等下一次。

字节流到应用帧的处理路径
字节流一次读到的字节数不固定
追加缓冲新字节接在旧数据后面
找帧头找不到就丢弃最早字节
取长度够一帧才继续,不够就等
校验交付通过就交应用,失败前进一字节

这里有三个边界必须处理。第一,缓冲区不能无限增长,要设上限;超过上限说明帧头或长度已经错了,必须丢弃最老的数据。第二,半帧要等,但不能无限等,要有超时清理。第三,校验失败只前进一个字节,不要清空整个缓冲,否则会把藏在后面的真帧一起扔掉。

还有一个容易漏的点:缓冲区里可能同时存在多帧。处理完一帧后不能直接返回,要循环继续找下一帧,直到缓冲区里不够一帧为止。很多「一次只解析第一帧」的 bug 就出在这里。

缓冲区大小通常按「最大帧长 × 2」来设。留一倍余量是为了应对「上一帧的尾巴还没处理完,下一帧已经来了」的情况;如果链路允许连续多帧堆积,还要再放大。

实现缓冲区有两种常见方式。整体前移最简单:每消费一帧,把剩下的字节往前挪。帧短、帧率低时没问题;帧率高时,拷贝量会随缓冲区长度增长,成为瓶颈。环形缓冲或「读偏移量」可以避免拷贝,代价是索引逻辑更绕,越界更容易写错。

用 Python 把数据切碎喂进去

下面这个解析器维护一个缓冲区,每次 feed 接收任意长度的片段,返回本次能交付的帧。帧格式沿用前面的 AA 55 + LEN + CMD + PAYLOAD + CRC16,长度只算负载。

class Parser:
    def __init__(self, max_payload=32):
        self.buf = b""
        self.max_payload = max_payload
        self.frames = []
        self.dropped = 0
        self.max_seen = 0

    def feed(self, chunk):
        self.buf += chunk
        self.max_seen = max(self.max_seen, len(self.buf))
        while True:
            idx = self.buf.find(b"\xAA\x55")
            if idx < 0:
                if len(self.buf) > 1:
                    self.dropped += len(self.buf) - 1
                    self.buf = self.buf[-1:]
                return
            if idx > 0:
                self.dropped += idx
                self.buf = self.buf[idx:]
            if len(self.buf) < 3:
                return
            ln = self.buf[2]
            if ln > self.max_payload:
                self.dropped += 1
                self.buf = self.buf[1:]
                continue
            end = 6 + ln
            if len(self.buf) < end:
                return
            if crc16_modbus(self.buf[2:4 + ln]) != \
                    struct.unpack("<H", self.buf[4 + ln:end])[0]:
                self.dropped += 1
                self.buf = self.buf[1:]
                continue
            self.frames.append((self.buf[3], self.buf[4:4 + ln]))
            self.buf = self.buf[end:]

构造两帧,总共 20 字节,按每片 3 字节喂进去。本机实际输出:

frame1: aa 55 03 01 01 02 03 71 5d
frame2: aa 55 05 81 48 45 4c 4c 4f 11 f0
total  : 20 bytes

 1 chunk=aa5503    buffer=aa5503                     frames=0  half frame, need 9 have 3
 2 chunk=010102    buffer=aa5503010102               frames=0  half frame, need 9 have 6
 3 chunk=03715d    buffer=-                          frames=1  no header
 4 chunk=aa5505    buffer=aa5505                     frames=1  half frame, need 11 have 3
 5 chunk=814845    buffer=aa5505814845               frames=1  half frame, need 11 have 6
 6 chunk=4c4c4f    buffer=aa55058148454c4c4f         frames=1  half frame, need 11 have 9
 7 chunk=11f0      buffer=-                          frames=2  no header

3-byte chunks -> frames=2 dropped=0 max_buffer=11
1-byte chunks -> frames=2 dropped=0 max_buffer=11
with garbage  -> frames=2 dropped=4 buffer=-
payloads      -> ['010203', '48454c4c4f']

前两步是典型的半帧:缓冲区里有帧头,但长度不够。第三步凑齐 9 字节,校验通过,交付第一帧,缓冲区被清空。第四步到第六步开始攒第二帧,长度是 5,整帧 11 字节,还差一点。第七步补齐,交付第二帧。

同样的数据换成一片一字节地喂,结果完全一样:两帧、丢弃 0、缓冲峰值 11 字节。这说明解析器的输出不依赖切分方式,只依赖字节内容。这一点很重要,它意味着你可以用「随机切分」来测试解析器,而不需要真的接硬件。

它也是写单元测试的基础:把抓到的字节流按任意边界切开,断言输出的帧序列不变。边界值要专门挑:正好切在一帧末尾、正好切在帧头两个字节中间、正好切在长度字段前面。这几个位置最容易暴露「差一字节」的问题。

最后一行是中间夹垃圾的情况:两帧之间塞了 00 13,解析器丢掉 4 个字节,仍然交付了两帧。丢的 4 个字节是开头的 FF FF 和中间的 00 13,都是无法组成帧的垃圾。

不要用「读到固定字节数就切一帧」来回避这个问题。固定长度只在协议本身定长、且链路绝对不丢字节时成立;现场只要丢一个字节,之后每一刀都会切错。

两种写法,代价差在哪

假设一次一帧

代码短,读一次解析一次,测试时很容易通过。代价是把链路行为当成了协议保证:发送方节奏一变、驱动缓冲一变、网络抖动一来,就会读到半帧或多帧。出错时症状是「偶尔错位」,很难复现,也很难定位。

缓冲加状态机

多一个缓冲区、多一层循环,代码量大约翻倍。好处是输入怎么切都不影响结果,半帧会等、多帧会连续处理、垃圾会被跳过。测试可以用随机切片来覆盖,问题能在本地复现,不用到现场碰运气。

两种写法的性能差别不大。缓冲加状态机多了一次内存拷贝和一次查找,对几十字节的帧可以忽略;真正的开销在「拷贝整个缓冲区」的实现上,如果每帧都把剩余数据前移,帧率高时会明显变慢。可以用环形缓冲或偏移量来避免。

选择其实没有悬念:只要链路是字节流,就该用缓冲。唯一可以用「一次一帧」的场景,是你能证明发送方每次只发一帧、且中间有足够长的间隔,并且接收端的读取时机可控。这种证明在现场几乎不成立。

超时、上限和丢弃策略

缓冲区不能只进不出。三种情况必须主动清理。

超过最大帧长。缓冲区里已经有帧头,但长度字段声明的帧长超过协议上限,说明这个帧头是假的,或者长度字段坏了。这时要前进一个字节重新找,而不是继续等一个永远等不到的帧。

超过缓冲上限。整个缓冲区超过预设大小,说明数据已经乱了。丢弃最老的部分,保留末尾一段,让最近的帧头有机会重新对齐。丢多少要按最大帧长来,保证剩下的空间还够解析一帧。

超时。半帧等了很久还没补齐,说明后面的数据丢了或者发送方停了。超时后清掉这段半帧,避免它和下一批数据拼成假帧。超时时间要大于「一帧的正常传输时间」,否则慢包会被误杀。

超时太短会丢慢包,太长会让半帧长期占着缓冲,还会在下一批数据到来时造成错位。一个实用的起点是「正常帧传输时间的三到五倍」,再按现场情况调。9600 波特率下,20 字节的帧大约 20 毫秒,超时可以设在 100 毫秒左右。

丢弃策略要可观测。丢了多少字节、丢的原因是什么,至少要有计数。没有计数,现场只能看到「偶尔少一帧」,没法判断是链路丢字节还是解析器自己扔的。

清理半帧有三种常见做法:直接清空缓冲区、只丢掉帧头之前的部分、保留最后一个可能的新帧头。直接清空最安全,但会连累已经收对的数据;保留新帧头最省数据,但实现复杂。多数场景选「丢弃到下一个帧头为止」,行为最容易解释。

出问题时先看哪里

现象真实原因第一步查什么
一次收到两帧,只解析了第一帧处理完一帧就返回,没有继续消费缓冲区看解析循环是不是 while 而不是 if
只收到半帧,后面一直错位解析器假设一次读到的就是一帧确认读取结果有没有先追加到缓冲区再切帧
帧头出现在缓冲区中间前面的垃圾字节没被丢弃,帧头位置没对齐检查找帧头失败时有没有丢弃最早字节
缓冲无限增长,内存上涨没有上限,也没有按帧消费看缓冲区最大长度和丢弃逻辑是否存在
超时后旧数据干扰新帧半帧没有清理,和新数据拼在一起确认超时清理有没有实现,阈值是否合理
TCP 正常,串口老出错串口没有重传,丢字节后同步丢失统计串口丢弃字节数,检查波特率和线缆
高帧率下 CPU 升高每帧都拷贝整个缓冲区,复杂度是平方级看缓冲区实现是否用了整体前移

边界与代价

缓冲要设上限,这是硬约束。上限太小,长帧会被误杀;太大,异常时内存会被吃光。按协议最大帧长乘以一个余量来设,并且在上限触发时保留足够重新对齐的空间。

超时是双刃剑。太短会丢慢包,太长会让半帧滞留。它没有唯一正确值,只能按链路的实际节奏来定。定完要写进文档,否则换个人维护时会随手改掉。

状态机增加代码复杂度。多一个状态,就多一组转移要测;状态越多,越容易出现「某个组合没覆盖到」。有限状态机的好处是可枚举、可测试,前提是你真的把每个转移都测了,而不是只测 happy path。

错误恢复一定会丢帧。校验失败、长度超限、超时清理,这些动作都会让某一帧被丢弃。协议要能接受「丢一帧」,业务层要有重试或容错,不能假设链路永远一帧不丢。

最大帧长还要和长度字段匹配。长度字段一字节,最大 255,缓冲上限就不能按 64KB 设;反过来,协议允许 4KB 的帧,接收端却只留 256 字节缓冲,长帧永远解析不出来。这两个数字必须一起定。

还有一个现实问题:缓冲加状态机解决的是「字节怎么切」,不解决「字节为什么错」。如果串口本身因为波特率误差、干扰在丢位,解析器再稳也只能丢帧。第 6 篇会讲物理层和总线选型,那里才是这类问题的源头。

今天就能验证的五个练习

  1. 把上面的解析器跑起来,把两帧数据按 1、2、3、5、7 字节切片分别喂一遍,确认输出帧数始终是 2。
  2. 把切片顺序打乱(比如先喂后半段再喂前半段),观察解析器会不会崩溃,记录它的行为。
  3. 在两帧之间插入 10 个随机字节,看丢弃计数增加多少,帧是否还能交付。
  4. 把 max_payload 改成 4,构造一个长度 5 的帧,确认它被当成假帧头丢弃而不是分配大缓冲。
  5. 给解析器加一个「最后收到数据的时间」,超过 100 毫秒没有新数据就清空半帧,写下你选择的阈值和理由。

小结

粘包和分包不是链路的 bug,是字节流的正常表现。接收端不能假设一次读到一帧,必须自己维护缓冲、找帧头、按长度取帧、校验后交付。半帧要等,垃圾要丢,缓冲要有上限,超时要清理。

下一篇讲超时、ACK 与重传。切帧解决的是「怎么把字节拼成消息」,还没解决「消息丢了怎么办」。在不可靠链路上,接收端可能永远等不到那半帧,发送端也不知道对方收没收到——那就要靠确认和重传,而重传本身又会带来重复执行的问题。