netty基础_10.Netty TCP 粘包和拆包及解决方案

最新推荐文章于 2024-09-03 14:42:05 发布
最新推荐文章于 2024-09-03 14:42:05 发布
阅读量288 收藏
点赞数
分类专栏： # netty 文章标签： .net tcp/ip 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wufagang/article/details/125023240
版权

TCP 粘包和拆包及解决方案

TCP 粘包和拆包及解决方案

TCP 粘包和拆包基本介绍

  1. TCP 是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的 socket，因此，发送端为了将多个发给接收端的包，更有效的发给对方，使用了优化方法（Nagle 算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样做虽然提高了效率，但是接收端就难于分辨出完整的数据包了，因为面向流的通信是无消息保护边界的
  2. 由于 TCP 无消息保护边界,需要在接收端处理消息边界问题，也就是我们所说的粘包、拆包问题,看一张图
  3. TCP 粘包、拆包图解

在这里插入图片描述

假设客户端分别发送了两个数据包 D1 和 D2 给服务端，由于服务端一次读取到字节数是不确定的，故可能存在以下四种情况：

  1. 服务端分两次读取到了两个独立的数据包，分别是 D1 和 D2，没有粘包和拆包
  2. 服务端一次接受到了两个数据包，D1 和 D2 粘合在一起，称之为 TCP 粘包
  3. 服务端分两次读取到了数据包，第一次读取到了完整的 D1 包和 D2 包的部分内容，第二次读取到了 D2 包的剩余内容，这称之为 TCP 拆包
  4. 服务端分两次读取到了数据包，第一次读取到了 D1 包的部分内容 D1_1，第二次读取到了 D1 包的剩余部分内容 D1_2 和完整的 D2 包。

TCP 粘包和拆包现象实例

在编写 Netty 程序时，如果没有做处理，就会发生粘包和拆包的问题

看一个具体的实例：

MyServer

package com.netty.zhanbao;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * @author wufagang
 * @description
 * @date 2022年06月12日 11:37
 */
public class MyServer {
    public static void main(String[] args) throws Exception{

        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {

            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class).childHandler(
                    new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            pipeline.addLast(new MyServerHandler());
                        }
                    }
            ); //自定义一个初始化类


            ChannelFuture channelFuture = serverBootstrap.bind(8000).sync();
            channelFuture.channel().closeFuture().sync();

        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }
}

MyServerHandler

package com.netty.zhanbao;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.Charset;
import java.util.UUID;

/**
 * @author wufagang
 * @description
 * @date 2022年06月12日 11:40
 */
public class MyServerHandler extends SimpleChannelInboundHandler<ByteBuf> {
    private int count;
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        byte[] buffer = new byte[msg.readableBytes()];
        msg.readBytes(buffer);

        //将buffer转成字符串
        String message = new String(buffer, Charset.forName("utf-8"));

        System.out.println("服务器接收到数据 " + message);
        System.out.println("服务器接收到消息量=" + (++this.count));

        //服务器回送数据给客户端, 回送一个随机id ,
        ByteBuf responseByteBuf = Unpooled.copiedBuffer(UUID.randomUUID().toString() + " ", Charset.forName("utf-8"));
        ctx.writeAndFlush(responseByteBuf);
    }

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

MyClient

package com.netty.zhanbao;

import com.netty.inbandhandlerandoutbandhandler.MyClientInitializer;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

/**
 * @author wufagang
 * @description
 * @date 2022年06月12日 11:42
 */
public class MyClient {
    public static void main(String[] args)  throws  Exception{

        EventLoopGroup group = new NioEventLoopGroup();

        try {

            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group).channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>(){

                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast(new MyClientHandler());
                        }
                    });

            ChannelFuture channelFuture = bootstrap.connect("localhost", 8000).sync();

            channelFuture.channel().closeFuture().sync();

        }finally {
            group.shutdownGracefully();
        }
    }
}

MyClientHandler

package com.netty.zhanbao;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.Charset;

/**
 * @author wufagang
 * @description
 * @date 2022年06月12日 15:00
 */
public class MyClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
    private int count;
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //使用客户端发送10条数据 hello,server 编号
        for(int i= 0; i< 10; ++i) {
            ByteBuf buffer = Unpooled.copiedBuffer("hello,server " + i, Charset.forName("utf-8"));
            ctx.writeAndFlush(buffer);
        }
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        byte[] buffer = new byte[msg.readableBytes()];
        msg.readBytes(buffer);

        String message = new String(buffer, Charset.forName("utf-8"));
        System.out.println("客户端接收到消息=" + message);
        System.out.println("客户端接收消息数量=" + (++this.count));

    }

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

关键代码: 这个地方是一个依赖tcp长链接,进行循环

//使用客户端发送10条数据 hello,server 编号
        for(int i= 0; i< 10; ++i) {
            ByteBuf buffer = Unpooled.copiedBuffer("hello,server " + i, Charset.forName("utf-8"));
            ctx.writeAndFlush(buffer);
        }

效果

在这里插入图片描述
可以看到第一次运行时，服务器一次性将10个数据都接收了，第二次运行时分六次接收的，这就很形象的看出了TCP的粘包现象。
服务器端接受到的消息都不一样,由于tcp是长链接导致的

其实这个也很好理解,我们解决也可以使用
1.固定长度
2.特殊分割符
3.自定义消息协议

TCP 粘包和拆包解决方案

  1. 常用方案：使用自定义协议+编解码器来解决
  2. 关键就是要解决服务器端每次读取数据长度的问题，这个问题解决，就不会出现服务器多读或少读数据的问题，从而避免的 TCP 粘包、拆包。

看一个具体的实例

  1. 要求客户端发送 5 个 Message 对象，客户端每次发送一个 Message 对象
  2. 服务器端每次接收一个 Message，分 5 次进行解码，每读取到一个 Message，会回复一个 Message 对象给客户端。

在这里插入图片描述

MessageProtocol 表示一条消息

package com.atguigu.netty.protocoltcp;


//协议包
public class MessageProtocol {
    private int len; //关键
    private byte[] content;

    public int getLen() {
        return len;
    }

    public void setLen(int len) {
        this.len = len;
    }

    public byte[] getContent() {
        return content;
    }

    public void setContent(byte[] content) {
        this.content = content;
    }
}

自定义编码器和解码器

package com.netty.zhanbao;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ReplayingDecoder;

import java.util.List;

/**
 * @author wufagang
 * @description
 * @date 2022年06月12日 15:12
 */
public class MyMessageDecoder extends ReplayingDecoder<Void> {
    @Override
    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf in, List<Object> out) throws Exception {
        System.out.println();
        System.out.println();
        System.out.println("MyMessageDecoder decode 被调用");
        //需要将得到二进制字节码-> MessageProtocol 数据包(对象)
        int length = in.readInt();

        byte[] content = new byte[length];
        in.readBytes(content);

        //封装成 MessageProtocol 对象，放入 out， 传递下一个handler业务处理
        MessageProtocol messageProtocol = new MessageProtocol();
        messageProtocol.setLen(length);
        messageProtocol.setContent(content);

        //放入out传给下一个hanlder进行处理
        out.add(messageProtocol);
    }
}


package com.netty.zhanbao;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;

/**
 * @author wufagang
 * @description
 * @date 2022年06月12日 15:14
 */
public class MyMessageEncoder extends MessageToByteEncoder<MessageProtocol> {
    @Override
    protected void encode(ChannelHandlerContext channelHandlerContext, MessageProtocol msg, ByteBuf out) throws Exception {
        System.out.println("MyMessageEncoder encode 方法被调用");
        out.writeInt(msg.getLen());
        out.writeBytes(msg.getContent());
    }
}

客户端修改

pipeline.addLast(new MyMessageEncoder());

将原来循环发送的消息包装成一个对象发送

@Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //使用客户端发送10条数据 hello,server 编号
        for(int i= 0; i< 10; ++i) {
//            MessageProtocol msg = new MessageProtocol();
//            ByteBuf buffer = Unpooled.copiedBuffer("hello,server " + i, Charset.forName("utf-8"));
//            ctx.writeAndFlush(buffer);
            String mes = "今天天气冷，吃火锅";
            byte[] content = mes.getBytes(Charset.forName("utf-8"));
            int length = mes.getBytes(Charset.forName("utf-8")).length;

            //创建协议包对象
            MessageProtocol messageProtocol = new MessageProtocol();
            messageProtocol.setLen(length);
            messageProtocol.setContent(content);
            ctx.writeAndFlush(messageProtocol);
        }
    }

服务端修改

pipeline.addLast(new MyMessageDecoder());//编码器

@Override
    protected void channelRead0(ChannelHandlerContext ctx, MessageProtocol msg) throws Exception {
//        byte[] buffer = new byte[msg.readableBytes()];
//        msg.readBytes(buffer);
//
//        //将buffer转成字符串
//        String message = new String(buffer, Charset.forName("utf-8"));
//
//        System.out.println("服务器接收到数据 " + message);
//        System.out.println("服务器接收到消息量=" + (++this.count));
//
//        //服务器回送数据给客户端, 回送一个随机id ,
//        ByteBuf responseByteBuf = Unpooled.copiedBuffer(UUID.randomUUID().toString() + " ", Charset.forName("utf-8"));
//        ctx.writeAndFlush(responseByteBuf);


        //接收到数据，并处理
        int len = msg.getLen();
        byte[] content = msg.getContent();

        System.out.println("服务器接收到信息如下");
        System.out.println("长度=" + len);
        System.out.println("内容=" + new String(content, Charset.forName("utf-8")));

        System.out.println("服务器接收到消息包数量=" + (++this.count));

        //回复消息
        System.out.println("服务端开始回复消息------");
        String responseContent = UUID.randomUUID().toString();
        int responseLen = responseContent.getBytes("utf-8").length;
        byte[]  responseContent2 = responseContent.getBytes("utf-8");
        //构建一个协议包
        MessageProtocol messageProtocol = new MessageProtocol();
        messageProtocol.setLen(responseLen);
        messageProtocol.setContent(responseContent2);

        ctx.writeAndFlush(messageProtocol);
    }

注意; 修改handler的泛型 MessageProtocol

效果

Client输出

MyMessageEncoder encode 方法被调用
MyMessageEncoder encode 方法被调用
MyMessageEncoder encode 方法被调用
MyMessageEncoder encode 方法被调用
MyMessageEncoder encode 方法被调用


//下面是客户端开始一个一个的收到服务端的回复
MyMessageDecoder decode 被调用
客户端接收到消息如下
长度=36
内容=1b5286dd-0fc2-4f62-9bf7-d5fad84179b5
客户端接收消息数量=1


MyMessageDecoder decode 被调用
客户端接收到消息如下
长度=36
内容=653d18cb-ab72-4163-8b95-09c94ecac873
客户端接收消息数量=2


MyMessageDecoder decode 被调用
客户端接收到消息如下
长度=36
内容=3be6e403-91bb-4437-ada8-6cdb9eb7ef00
客户端接收消息数量=3


MyMessageDecoder decode 被调用
客户端接收到消息如下
长度=36
内容=94c8f306-fd9c-455a-956c-16698ce4150b
客户端接收消息数量=4


MyMessageDecoder decode 被调用
客户端接收到消息如下
长度=36
内容=7890de9c-0fa2-4317-8de1-1d464315fa1b
客户端接收消息数量=5

Server输出

MyMessageDecoder decode 被调用
服务器接收到信息如下
长度=27
内容=今天天气冷，吃火锅
服务器接收到消息包数量=1
服务端开始回复消息------
MyMessageEncoder encode 方法被调用


MyMessageDecoder decode 被调用
服务器接收到信息如下
长度=27
内容=今天天气冷，吃火锅
服务器接收到消息包数量=2
服务端开始回复消息------
MyMessageEncoder encode 方法被调用


MyMessageDecoder decode 被调用
服务器接收到信息如下
长度=27
内容=今天天气冷，吃火锅
服务器接收到消息包数量=3
服务端开始回复消息------
MyMessageEncoder encode 方法被调用


MyMessageDecoder decode 被调用
服务器接收到信息如下
长度=27
内容=今天天气冷，吃火锅
服务器接收到消息包数量=4
服务端开始回复消息------
MyMessageEncoder encode 方法被调用


MyMessageDecoder decode 被调用
服务器接收到信息如下
长度=27
内容=今天天气冷，吃火锅
服务器接收到消息包数量=5
服务端开始回复消息------
MyMessageEncoder encode 方法被调用

无论运行几次，Server都是分5次接收的，这样就解决了TCP粘包问题。

总结

所谓的毡包,拆包就是长链接导致的数据流不知道何时取多长
自定义消息协议,就是将数据包装到一个对象里面,使用对象进行传递

Netty中粘包和拆包的解决方案
一个无限死循环的博客
10-10 737
粘包和拆包是TCP网络编程中不可避免的，无论是服务端还是客户端，当我们读取或者发送消息的时候，都需要考虑TCP底层的粘包/拆包机制。 TCP粘包和拆包 TCP是个“流”协议，所谓流，就是没有界限的一串数据。TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分，所以在业务上认为，一个完整的包可能会被TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发...
netty解决tcp粘包和拆包问题
远方的少年
01-20 2937
tcp为了提高效率会将多个数据包批量发送过来，所以就会存在粘包和拆包的问题。使用Netty,可以通过自定义协议+编解码器来解决粘包和拆包的问题。 1.定义协议 public class MessageProtocol { private int len; private byte[] content; public int getLen() { return len; } public void setLen(int len) {
TCP 粘包和拆包及解决方案
可小辉的博客
02-01 1462
目录 1.TCP粘包和拆包基本介绍 2.TCP粘包和拆包现象实例 3.TCP粘包和拆包解决方案 4.具体实例 1.TCP粘包和拆包基本介绍 TCP是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发给接收端的包，更有效的发给对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样做虽然提高了效率，但是接收端就难于分辨出完整的数据包了，因为面向流的...
【netty系列-09】深入理解和解决tcp的粘包拆包
最新发布
zhenghuishengq的博客
09-03 1304
深入理解和解决tcp的粘包拆包问题
tcp粘包和拆包的处理方案
daxiaojianghujs2016的博客
03-03 2032
随着智能硬件越来越流行，很多后端开发人员都有可能接触到socket编程。而很多情况下，服务器与端上需要保证数据的有序，稳定到达，自然而然就会选择基于tcp/ip协议的socekt开发。开发过程中，经常会遇到tcp粘包，拆包的问题，本文将从产生原因，和解决方案以及workerman是如何处理粘包拆包问题的，这几个层面来说明这个问题。 什么是粘包拆包 对于什么是粘包、拆包问题，我想先举两...
TCP粘包/拆包及解决方法
weixin_42579072的博客
01-06 740
我想先举两个简单的应用场景： 1）客户端和服务器建立一个连接，客户端发送一条消息，客户端关闭与服务端的连接。 2）客户端和服务器简历一个连接，客户端连续发送两条消息，客户端关闭与服务端的连接。 对于第一种情况，服务端的处理流程可以是这样的：当客户端与服务端的连接建立成功之后，服务端不断读取客户端发送过来的数据，当客户端与服务端连接断开之后，服务端知道已经读完了一条消息，然后进行解码和后续处理…。 ...
Netty如何解决TCP中的粘包和拆包问题
lengyingzhang的博客
07-29 3274
粘包和拆包是TCP网络编程中不可避免的，无论是服务端还是客户端，当我们读取或者发送消息的时候，都需要考虑TCP底层的粘包/拆包机制。TCP是个“流”协议，所谓流，就是没有界限的一串数据。TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分，所以在业务上认为，一个完整的包可能会被TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发送，这就是所谓的TCP粘包和拆包问题。...
使用Netty解决TCP粘包和拆包问题过程详解
08-25
使用Netty解决TCP粘包和拆包问题过程详解 Netty是一个流行的Java网络编程框架，提供了简洁、灵活的API来处理网络编程的各种问题。其中，解决TCP粘包和拆包问题是Netty的一个重要应用场景。本文将详细介绍使用Netty...
粘包和拆包及Netty解决方案.docx
10-26
### 粘包和拆包及Netty解决方案 #### 一、粘包和拆包问题概述 在计算机网络通信中，特别是在使用TCP/IP协议栈进行数据传输的过程中，常常会遇到粘包和拆包的问题。这类问题主要出现在客户端和服务端通过TCP连接...
Netty粘包拆包问题解决方案
08-18
Netty 粘包拆包问题解决方案 Netty 是一个基于 Java 的网络编程框架，它提供了一个便捷的方式来处理网络数据的读写操作。然而，在使用 Netty 进行网络编程时，经常会遇到粘包和拆包的问题。所谓粘包和拆包，就是指...
Netty中粘包和拆包的解决方案.docx
10-26
在TCP网络编程中，粘包和拆包是常见的问题，...总的来说，Netty通过提供一系列的解码器，使得处理TCP粘包和拆包问题变得更加便捷，开发者可以根据实际业务需求灵活选择或自定义解码策略，保证数据的正确传输和解析。
tcp 粘包 拆包解决思路以代码
04-25
tcp 粘包 拆包解决思路以代码，提供DEMO，采用 包长+内容缓冲区 组织方法，未采用分隔符以及定长包，因为我觉得包长+内容缓冲区比较灵活
netty解决TCP粘包和拆包
daliucheng的博客
08-03 197
netty解决TCP粘包和拆包1. TCP粘包现象出现的原因1.1 现象重显2. 解决思路3. netty解决方法 1. TCP粘包现象出现的原因 TCP 是面向连接，面向流，可以提供高可靠性，在发送数据的时候，因为TCP发送数据是按照数据块的，为了提供发送的效率，发送端会将多个小的数据数据包合并在一块（主要是Nagle算法），更好的发送数据。这样就出现了一个新的问题，接收端不能识别出来原始数据，这就是粘包。 说明: 第一行所示，data1和data2都是两次独立的包，没有发生粘包。 第二行所示，da
TCP粘包/拆包问题的解决方法
weixin_42574365的博客
07-26 1290
1.什么是TCP的粘包/拆包 TCP的粘包和拆包，指的是上层同一个业务逻辑中的数据可能再发送过程中被TCP拆成多个包，或多个小包连成一个大包发送出去，从而导致业务处理逻辑出错的问题。 造成TCP粘包/拆包的原因： 应用程序写入的字节长度大于发送缓冲区大小； 进行MSS大小的TCP分段； 以以太帧的payload大于MTU进行IP分片。 2.怎么解决粘包/拆包问题 3.粘包/拆包问题案例 4.使用Netty解决粘包/拆包问题 ...
TCP粘包、拆包及解决办法
qq_27198345的博客
08-06 350
TCP粘包、拆包及解决办法 文章目录TCP粘包、拆包及解决办法1. TCP会发生粘包、拆包，UDP会发生粘包、拆包吗？2. 什么是粘包、拆包？为什么会发生TCP粘包、拆包？3. 粘包、拆包解决办法 1. TCP会发生粘包、拆包，UDP会发生粘包、拆包吗？ TCP、UDP是传输层的协议，TCP会发生粘包，UDP会发生粘包吗？ UDP不会发生粘包现象。UDP是基于报文发送的，从UDP的帧结构可以看出，在UDP首部采用了16bit来只是UDP数据报文的长度，因此在应用层能够很好地将不同的数据报文区分开，从而避免粘
解决TCP粘包/拆包问题的方法及示例
polsnet的专栏
05-11 3766
还有一种解决TCP粘包/拆包问题的方法是使用定长协议，即规定每次发送的数据包都是固定长度，例如规定每次发送的数据包长度为固定的100个字节，如果发送的数据长度不足100字节，则在后面填充空格或者其他特定字符，如果超过100字节，则进行截断处理。由于网络的不可靠性，TCP为了提高传输效率，会将多个小数据块打包成一个大的数据块一起发送（称为TCP粘包），或者将一个大的数据块拆分成多个小的数据块发送（称为TCP拆包）。由于TCP是面向流的协议，发送的数据流会被自动分段，可能出现多个短消息被粘在一起发送的情况。
TCP粘包拆包及NETTY解决方案
一笑的博客
04-14 2958
TCP粘包拆包及NETTY解决方案
Netty学习——Netty解决TCP粘包与拆包问题
胡海龙
03-11 4600
TCP 粘包与拆包 TCP是一个“流”协议，TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分，所以在业务上认为，一个完整的包可能会被TCP拆分成多个包进行发送，也有可能把多个小包封装成一个大的数据包进行发送，这就是TCP的粘包和拆包问题。 TCP 粘包与拆包问题说明 假设客户端分别发送了俩个数据包D1和D2到服务端。但服务端每次读到的字节数是不确定的，所以可能存在下面四种情况： 服务端分两次读取到了D1和D2数据包，也就是理想的正常情况，没有发生粘包和拆包。 服务端一
TCP粘包 拆包 及其解决办法
mmmmhello的博客
12-14 225
1、udp 会发生粘包吗？ 由于tcp 是面向连接的，客户端连接服务端必须二者都有自己的套接字，而udp不是面向连接的，接收端缓冲区利用链式结构来记录每一次到达的udp包，所以不会发生粘包问题。 2、tcp 在哪些情况下会发生 粘包问题？ 发送端数据包过小 一次发送多个分组（Nagle算法）。 接收端 应用层未及时处理缓冲区的数据，导致多个包粘粘在一起。 3、如何解决tcp粘包问题？ 通过上面的叙述，我们可以认识到接收到的报文不一定就是整个数据包消息。如何区分是不是一整包消息：在包头说明长度。 另外在接收端
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值