我们知道，TCP 是面向字节流的协议，它没有消息边界。

也就是说，发送端调用一次 write()，并不能保证接收端一次 read() 就能收到。

* 粘包：发送端发送了两次消息（msg1 + msg2），接收端一次 read 就受到了 msg1msg2 连在一起
* 半包：发送端发了一次完整消息（比如1024字节），接收端一次 read 只收到了前300字节，剩下的700字节下次才到

常见触发场景：
* Nagle 算法 + 小数据量频繁发送 → 粘包
* MTU 限制、大消息、拥塞控制、网络延迟 → 半包

示例代码
```java
// 制造粘包 + 半包
String[] message = new String[]{
        "床前明月光",
        "疑是地上霜",
        "举头望明月",
        "低头思故乡"
};
for (String msg : message) {
    ByteBuf buf = ch.alloc().buffer();
    buf.writeBytes(msg.getBytes());
    ch.writeAndFlush( buf);
}

ch.writeAndFlush(ch.alloc().buffer().writeBytes("hi".getBytes()));
Thread.sleep(100);

String longMsg = "床前明月光疑是地上霜举头望明月低头思故乡".repeat(20);
ch.writeAndFlush(ch.alloc().buffer().writeBytes(longMsg.getBytes()));

Thread.sleep(2000); // 保持连接看测试效果
```
演示效果
```
服务器一次读到：15 字节：床前明月光
服务器一次读到：30 字节：疑是地上霜举头望明月
服务器一次读到：17 字节：低头思故乡hi
服务器一次读到：1024 字节：床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床�
服务器一次读到：176 字节：��明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡
```

我们很明显观察到，

第一句单独 15 字节，属于单包，刚好赶上 TCP 分段边界

第二、三句粘成 30 字节，属于粘包，客户端连续 writeAndFulsh 太快，TCP 把两个小包合并成一个包发送

“低头思故乡” + “hi” 粘成 17 字节，属于粘包，Nagle 算法把小数据包合并，hi 也被粘进去了

超长消息被拆成 1024 + 176 字节，属于半包，因为超过 MTU（通常 1460 字节左右），加上 Netty 内部读缓冲区限制

第二段出现乱码，属于半包后遗症，因为上次读走 1024 字节后，剩余字节还在内核缓冲区，下次才到

### 解决方法
这里只介绍几个 netty 官方推荐的做法

#### 方案一：固定长度
服务端和客户端定好每次发送的业务数据包长度，不够长度填充指定的字符，服务端每次按照固定长度去读取

Server 代码示例
```java
private static final int MESSAGE_LENGTH = 15;  // 每条消息固定 15 字节（床前明月光正好15字节UTF-8）

    public static void main(String[] args) throws Exception {
        EventLoopGroup boss = new NioEventLoopGroup(1);
        EventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(boss, worker)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            ch.pipeline().addLast(new FixedLengthFrameDecoder(MESSAGE_LENGTH));

                            ch.pipeline().addLast(new SimpleChannelInboundHandler<ByteBuf>() {
                                @Override
                                protected void channelRead0(ChannelHandlerContext ctx, ByteBuf buf) {
                                    byte[] bytes = new byte[MESSAGE_LENGTH];
                                    buf.readBytes(bytes);
                                    String msg = new String(bytes).trim(); // trim 去掉可能的空格填充
                                    System.out.println("【收到完整固定长度消息】: " + msg);
                                }

                                @Override
                                public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
                                    cause.printStackTrace();
                                    ctx.close();
                                }
                            });
                        }
                    });

            ChannelFuture f = b.bind(8080).sync();
            System.out.println("固定长度拆包服务器启动成功 8080... 每条消息强制15字节");
            f.channel().closeFuture().sync();
        } finally {
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }
```
Client 代码示例
```java
// 发送方式如下
private static void sendFixed(Channel ch, String content) {
    byte[] src = content.getBytes();
    ByteBuf buf = ch.alloc().buffer(15);
    buf.writeBytes(src);
    // 不足15字节的用空格填充
    for (int i = src.length; i < 15; i++) {
        buf.writeByte(' ');
    }
    ch.writeAndFlush(buf);
}

// 使用方式如下
sendFixed(ch, "床前明月光");
sendFixed(ch, "疑是地上");  // 少一个字，补空格
sendFixed(ch, "举头望明月");
sendFixed(ch, "低头思故");   // 同上
sendFixed(ch, "hi");           // 只有2字节，也会补13个空格

// 长消息也截断成多条15字节发
String longMsg = "床前明月光疑是地上霜举头望明月低头思故乡".repeat(20);
for (int i = 0; i < longMsg.length(); i += 15) {
    int end = Math.min(i + 15, longMsg.length());
    sendFixed(ch, longMsg.substring(i, end));
}
```

效果演示
```
固定长度拆包服务器启动成功 8080... 每条消息强制15字节
【收到完整固定长度消息】: 床前明月光
【收到完整固定长度消息】: 疑是地上
【收到完整固定长度消息】: 举头望明月
【收到完整固定长度消息】: 低头思故
【收到完整固定长度消息】: hi
【收到完整固定长度消息】: 床前明月光
【收到完整固定长度消息】: 疑是地上霜
【收到完整固定长度消息】: 举头望明月
【收到完整固定长度消息】: 低头思故乡
【收到完整固定长度消息】: 床前明月光
...
```

#### 方案二：分隔符
同样，服务端和客户端定好业务数据分隔符，服务端接收数据时，只有当收到分隔符时，才判断分隔符前的所有数据是一个完整的业务数据，否则继续等待分隔符

Server代码示例
```java
socketChannel.pipeline().addLast(new DelimiterBasedFrameDecoder(8192, Delimiters.lineDelimiter()));

socketChannel.pipeline().addLast(new SimpleChannelInboundHandler<ByteBuf>() {
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf buf) {
        String msg = buf.toString(StandardCharsets.UTF_8);
        System.out.println("收到消息：" + msg);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
});
```
Client代码示例
```java
String[] msgs = {
        "床前明月光",
        "疑是地上霜",
        "举头望明月",
        "低头思故乡"
};

for (String msg : msgs) {
    ByteBuf buf = ch.alloc().buffer();
    buf.writeBytes((msg + '\n').getBytes());
    ch.writeAndFlush( buf);
}

String longLine = "床前明月光疑是地上霜举头望明月低头思故乡".repeat(20);
ch.writeAndFlush(ch.alloc().buffer().writeBytes((longLine + "\n").getBytes()));
```
效果演示
```
分隔符服务器启动成功 8080...使用 \n 作为消息边界
收到消息：床前明月光
收到消息：疑是地上霜
收到消息：举头望明月
收到消息：低头思故乡
收到消息：床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜举头望明月低头思故乡床前...
```

#### 方案三：自定义包结构体
每次发送数据前，将数据的长度也带上，但是存放数据长度的位置一定要定好，否则服务端无法识别哪个字节代表的是数据长度

Server代码示例
```java
ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(
        10 * 1024 * 1024, // maxFrameLength
        0,                // lengthFieldOffset
        4,                // lengthFieldLength
        0,                // lengthAdjustment
        4                 // initialBytesToStrip 跳过长度字段
));

// 发送时自动加上长度字段（客户端也要加）
ch.pipeline().addLast(new LengthFieldPrepender(4));
```
Client代码示例
```java
@Override
protected void initChannel(NioSocketChannel ch) {
    ch.pipeline().addLast(new LengthFieldPrepender(4));           // 自动加长度
    ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(10*1024*1024, 0, 4, 0, 4));
}
```
效果演示
```
自定义协议服务器启动成功 8080... 使用 length(4字节) + body 结构
【收到完整自定义协议消息】长度=19 内容: 床前明月光
【收到完整自定义协议消息】长度=19 内容: 疑是地上霜
【收到完整自定义协议消息】长度=19 内容: 举头望明月
【收到完整自定义协议消息】长度=19 内容: 低头思故乡
【收到完整自定义协议消息】长度=6 内容: hi
【收到完整自定义协议消息】长度=60004 内容: 床前明月光疑是地上霜举头望明月低头思故乡床前明月光疑是地上霜...
```

这里解释一下，`LengthFieldBasedFrameDecoder` 负责解决TCP粘包/半包问题，根据长度字段自动拆分成完整的消息帧。

构造函数里的参数：

maxFrameLength - 最大帧长度，超过则抛出异常

lengthFieldOffset - 长度字段的偏移量（从0开始）

lengthFieldLength - 长度字段占用的字节数

lengthAdjustment - 长度调整值（长度字段的值是否需要调整）

initialBytesToStrip - 解码后跳过的字节数

也就是说，发送端调用一次 write()，并不能保证接收端一次 read() 就能收到。

详解 TCP 中的粘包半包问题，以及在 netty 中的解决方案

编程语言

前端

人工智能

TCP粘包与半包问题解析：介绍TCP协议中常见的粘包和半包现象，分析Nagle算法、MTU限制等触发原因，提供Netty框架下的三种解决方案（固定长度、分隔符、自定义协议），包含Java代码示例和效果演示，帮助开发者有效解决网络通信中的数据包处理问题。

网络延迟

服务器

4核4G3M云服务器 新用户低至38元/年！

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

详解 TCP 中的粘包半包问题，以及在 netty 中的解决方案-腾讯云开发者社区-腾讯云

详解 TCP 中的粘包半包问题，以及在 netty 中的解决方案

详解 TCP 中的粘包半包问题，以及在 netty 中的解决方案

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐