你的服务器没丢包,它把一条消息吃成了两条:TCP 粘包半包与 ByteBuf 泄漏的现场

2026-11-16 12 0

你的服务器没丢包,它把一条消息吃成了两条:TCP 粘包半包与 ByteBuf 泄漏的现场

凌晨一点,值班手机响了。告警写着:下游收到重复指令,某个自动扩容任务被执行了三次。查了一圈,网关、消息队列、业务库全清白。最后一段抓包让我血压飙升——TCP 包干干净净,一个都没丢。

真正的原因是:对端把一条 TCP 连接上的字节流,当成了消息边界。发送方一次 write 写了三段,接收方一次 read 读出两个半包;或者相反,两条消息被一次 read 吞进同一个缓冲区。

这就是"粘包/半包"。教科书上它躺在"网络编程基础"那一章,配一句"UDP 有边界,TCP 没边界",考试两分,工作两年。而绝大多数事故现场,没人再背这句话了。


一、TCP 之所以"粘",是因为它压根没有消息这个概念

先纠正一个常见误解:TCP 不是"会把包粘起来",TCP 的交付语义是有序字节流,它连"包"这个概念都没有。MSS 只是内核发送时的切片策略,跟对端应用看到的东西毫无关系。

// 发送方
buf.writeInt(4);
buf.writeInt(payload.length);
buf.writeBytes(payload);
socket.getOutputStream().write(buf.array());   // 一次 write,三段数据

// 接收方
byte[] data = new byte[1024];
int n = socket.getInputStream().read(data);     // 读到了什么?没人知道

接收方那句 read 到底返回 6 字节、12 字节还是 900 字节,取决于此刻内核缓冲区里恰好攒了多少数据、网络拥塞程度、接收方 read 的时机、甚至对端 Nagle 算法和 delayed ACK 的互动。唯一能保证的只有"顺序不乱、字节不丢"。

换句话说:TCP 给你的是一条无限长的、没有分隔符的字节河。把河水分成一桶桶一桶,是你的活儿。

这就是为什么 UDP 保留了报文边界,而 TCP 没有——UDP 用"可能丢、可能乱、可能重复"换来了"边界明确",TCP 反过来。你选哪个,本质是选哪种失败模式。


二、三种分帧方案,和它们的坑

1. 固定长度。每条消息恒定 N 字节。实现最简单,但浪费带宽,且要求业务长度上限已知——真实业务里总有个"备注字段"能塞进一兆。

2. 分隔符。用换行、\0 切。最朴素,人可读,但内容里出现分隔符就得转义,JSON 文本协议尤其烦人。

3. 长度前缀(TLV)。帧头声明 body 长度,读够 headerLen + bodyLen 才算一条消息。生产环境就用它,没有例外。

// 读取循环的教科书写法(伪代码)
while (true) {
    if (!readFully(headerBuf, 8)) break;          // 1. 先确保帧头到齐
    int bodyLen = decodeLength(headerBuf);        //    长度要校验
    if (!readFully(bodyBuf, bodyLen)) break;      // 2. 再确保 body 完整(半包核心)
    dispatch(bodyBuf);                            // 3. 到齐了才处理
}

关键在第 2 步:数据不够就挂着等,够了才处理。这里的"等"是安全的,但也是事故高发地。


三、Netty 的解码器:参数填错就是一场雪崩

用 Netty 的话,上面那段手写循环已经被封装好了:

ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(
    1024 * 1024,   // maxFrameLength:单帧上限
    4,             // lengthFieldOffset:长度字段偏移
    4,             // lengthFieldLength:长度字段字节数
    0,             // lengthAdjustment:额外偏移
    0              // initialBytesToStrip:剥离字节数
));

五个参数里,maxFrameLength 最危险,因为它同时承担两个角色:合法上限和攻击防护。设太大,一个畸形的长度头(比如 0x7FFFFFFF)就能让 Netty 申请 2GB 堆外内存;设太小,正常粘包被拆成两半,解码器抛异常,连接被关闭。

更狠的是异常风暴。恶意客户端持续发半包,TooLongFrameException 每秒抛上千次,默认异常处理器会打爆日志、占满磁盘——攻击者用一个长度头就能打穿你的磁盘配额。所以解码器必须配自定义异常处理器:至少做到"限频打印 + 计数上报 + 关闭连接",别让异常一路冒到日志框架。

顺带吐槽:initialBytesToStrip=0 意味着你拿到的 ByteBuf 里还带着帧头,业务代码得自己再跳 8 个字节。设成 8 又会把长度字段一起切掉。两种都对,取决于你的协议是否需要 magic 和 version 做校验——通常需要。


四、ByteBuf 引用计数:一行 release() 没写,内存就永远回不来

Netty 的 ByteBuf 有引用计数:池化分配 + 引用计数,让内存能精确归还。

ByteBuf buf = alloc.buffer(1024);
try {
    buf.writeBytes(payload);
    channel.writeAndFlush(buf).addListener(future -> {
        if (!future.isSuccess()) buf.release();   // 写失败要手动释放
    });
    // 成功时所有权已交给 channel,不要再 release
} catch (Exception e) {
    buf.release();
    throw e;
}

这个模式有个巨大的坑:writeAndFlush 之后所有权转移给 Channel,一旦异步写失败,引用计数永远不归零,池化内存无法回收。而池化分配器是按内存区域(chunk)管理的,一块 16MB 的 chunk 只要有任意一个 buffer 没释放,这 16MB 就整体回不去。

结果是:进程 RSS 缓慢上涨,堆内堆外比例严重失调,最后被 OOM Killer 干掉,而代码里找不到任何泄漏点。Netty 自带的 ResourceLeakDetector 能救你一命:

ResourceLeakDetector.setLevel(Level.PARANOID);   // 每次分配都采样上报

调试期用 PARANOID(有开销),生产用 SIMPLE。它会打印泄漏 buffer 的申请栈——ByteBufAllocator.newDirectBuffer 之后的调用链,就是破案线索。我见过最离谱的一次,泄漏点在日志框架的 MDC 里:一个 ThreadLocal 存了 buffer,线程池复用导致引用一直挂着。

还有第二个坑更隐蔽:Netty 的 EventLoop 线程数默认是 CPU 核数的 2 倍。如果你在 channelRead 里做耗时操作(查库、调 RPC、序列化大对象),不是"变慢一点",而是这个 EventLoop 上所有连接全部卡住。表现是:某个客户端延迟飙升,监控上看却是"服务端 CPU 很闲"。


五、Go 侧的两个经典陷阱

Go 里最常用的是 bufio.Scanner:

scanner := bufio.NewScanner(conn)
for scanner.Scan() {
    handle(scanner.Bytes())   // 危险:Bytes() 返回的是底层数组的切片
}
// scanner.Err() 必须检查!EOF / bufio.ErrTooLong

两个坑:其一,默认单行上限 64KB,超过直接返回 bufio.ErrTooLong,连接静默断开——忘了检查 scanner.Err(),你甚至不知道发生了什么。其二,scanner.Bytes() 返回的是内部缓冲区的引用,下一次 Scan() 就会复用并覆盖。如果你把切片存进 map 或异步投递出去,你会拿到一串被后续数据污染的乱码。这两个 bug 在压测时都很难复现,因为它们取决于"行有多长"和"扫描得多快"。

另一个是 bufio.Reader.ReadSlice:语义是"只读当前缓冲区里的数据",缓冲不够就返回 ErrBufferFull,数据其实还在内核缓冲区里没丢。但很多人在这里直接 break 掉——这就等于丢包,而且丢得理直气壮。


六、怎么确认真的是粘包,而不是别的锅

动手改代码之前,先做三件事:

1. 抓包看边界。注意:TCP 段的边界和你要解析的协议边界毫无关系,两个逻辑消息粘在一个段里是正常的,一个逻辑消息被切成三段也是正常的。看到"粘"不要慌,要看的是你的解析器能不能正确重组。

2. 在应用层打印"重组后"的长度。如果长度字段本身对不上,问题在发送端;如果对得上但业务重复,那问题不在粘包。

3. 排除重试和超时。我那次事故的根因排查到最后,发现重复指令其实是上游超时后重试导致的,"重试"和"粘包"叠加在一起,才让我误判了方向。顺序很重要:先确认链路层没有丢包、没有重复(用 ss -ti 看重传和乱序计数),再往应用层看分帧。


七、落地清单

1. 协议必须自带长度前缀或分隔符,永远不要依赖"一次 read 对应一条消息"。这是 TCP 编程的第一性原理。

2. 长度字段必须有上限校验。负数、超大值、非法 magic 全部当场拒绝并断连,别让它走到内存分配那一步。

3. 帧头里放 magic 和 version。版本升级时新旧客户端混跑,你才有一手拒绝旧协议的底气。

4. 解码器之外,一定要自定义异常处理器。限频、计数、断开连接三件套。

5. EventLoop 里不做耗时操作。耗时的活儿丢到业务线程池。

6. Buffer 所有权写进注释。谁创建谁释放、异步写失败怎么办——团队里十个新人有九个不知道 writeAndFlush 之后能不能 release。

7. 上线前开一次 PARANOID 级别泄漏检测跑压测。能省掉线上几个月的玄学排查。


八、最后

那次事故最后怎么修的?

不是加锁,不是扩容,也不是"加个重试"。只是给协议加了一个 4 字节的长度前缀,然后把那段"读多少算多少"的代码,换成了"读够为止"。

说起来有点荒诞——我们花了两周怀疑网络、怀疑机房、怀疑中间件,最后发现是自己没定义消息边界。而这个问题,在任何一本讲 TCP 的书的第一章就写着。

技术的浪漫大概就是这样:最贵的 bug,往往藏在最朴素的那句前提里——字节流没有边界,所以边界得你自己画。

祝你的协议,永远对得上。

相关文章

你的系统不会崩溃,它只是学会了慢慢死:背压、流控与队列里那些看不见的等待
别再问 epoll 过时没:io_uring 到底能把你的服务快多少
虚拟线程让接口更慢了:Java 21 Loom 一次 pinning 事故的现场复盘
Python 异步编程翻车实录:asyncio 那些坑,我替你踩了一遍
你刚改完的数据怎么读不到了:MySQL 主从延迟这块黑箱,比你想象的黑
你的数据库连接池正在悄悄排队:21 个线程抢 10 个连接,然后集体石化

发布评论