你的服务器没丢包,它把一条消息吃成了两条: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,往往藏在最朴素的那句前提里——字节流没有边界,所以边界得你自己画。
祝你的协议,永远对得上。