九、TCP粘包和拆包及解决方案

最新推荐文章于 2024-02-29 09:58:51 发布
最新推荐文章于 2024-02-29 09:58:51 发布
阅读量1.9k 收藏 4
点赞数
分类专栏： Netty 文章标签： netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43676950/article/details/122704627
版权

9.1、TCP粘包和拆包基本介绍

  1. TCP是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的Socket，因此，发送端为了将多个发给接收端的包，更有效的发给对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样做虽然提高了效率，但是接收端就难于分辩出完整的数据包了，因为面向流的通信是无消息保护边界的。

  2. 由于TCP无消息保护边界，需要在接收端处理消息边界问题，也就是我们所说的粘包、拆包问题、

  3. TCP粘包、拆包示意图

在这里插入图片描述

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

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

9.2、TCP粘包和拆包现象实例

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

package com.feng.netty.tcp;

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

public class MyServer {
    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new MyServerHandler());
            ChannelFuture channelFuture = serverBootstrap.bind(7000).sync();
            channelFuture.channel().closeFuture().sync();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}


package com.feng.netty.tcp;

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;

public class MyServerHandler extends SimpleChannelInboundHandler<ByteBuf> {
    private  int count;

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

    @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);
    }
}


package com.feng.netty.tcp;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;

public class MyServerInitializer extends ChannelInitializer<SocketChannel> {

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


package com.feng.netty.tcp;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

public class MyClient {
    public static void main(String[] args) throws InterruptedException {

        EventLoopGroup group = new NioEventLoopGroup();

        try {

            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group).channel(NioSocketChannel.class)
                    .handler(new MyClientInitializer()); //自定义一个初始化类

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

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

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


package com.feng.netty.tcp;

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;

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();
    }
}


package com.feng.netty.tcp;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;

public class MyClientInitializer extends ChannelInitializer<SocketChannel> {

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

9.3、TCP粘包和拆包解决方案

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

9.4、具体实例

  1. 要求客户端发送5个Message，客户端每次发送一个Message对象

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

在这里插入图片描述

  1. 代码演示

    package com.feng.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.feng.netty.protocoltcp;

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

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());
    }
}


    package com.feng.netty.protocoltcp;

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

import java.util.List;

public class MyMessageDecoder extends ReplayingDecoder<Void> {

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        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.add(messageProtocol);
    }
}


    package com.feng.netty.protocoltcp;

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

public class MyServer {
    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup,workGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new MyServerInitializer());//自定义一个初始化类
            ChannelFuture channelFuture = serverBootstrap.bind(7000).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }
}


    package com.feng.netty.protocoltcp;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;

public class MyServerInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast(new MyMessageDecoder());//解码器
        pipeline.addLast(new MyMessageEncoder());//编码器
        pipeline.addLast(new MyServerHandler());
    }
}


    package com.feng.netty.protocoltcp;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

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

public class MyServerHandler extends SimpleChannelInboundHandler<MessageProtocol> {

    private int count;
    //处理业务的handler
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, MessageProtocol msg) throws Exception {
        //接收到数据，并处理
        int len = msg.getLen();
        byte[] content = msg.getContent();

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

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

        //回复消息
        String responseContent = UUID.randomUUID().toString();
        int responseLen = responseContent.getBytes(Charset.forName("utf-8")).length;
        byte[] responseContent2 = responseContent.getBytes(Charset.forName("utf-8"));
        //构建一个协议包
        MessageProtocol messageProtocol = new MessageProtocol();
        messageProtocol.setLen(responseLen);
        messageProtocol.setContent(responseContent2);
        ctx.writeAndFlush(messageProtocol);
    }

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


    package com.feng.netty.protocoltcp;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

public class MyClient {

    public static void main(String[] args) throws InterruptedException {

        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new MyClientInitializer());
            ChannelFuture channelFuture = bootstrap.connect("localhost", 7000).sync();
            channelFuture.channel().closeFuture().sync();
        }finally {
            group.shutdownGracefully();
        }
    }
}


    package com.feng.netty.protocoltcp;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;

public class MyClientInitializer extends ChannelInitializer<SocketChannel> {

    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast(new MyMessageEncoder());//加入编码器
        pipeline.addLast(new MyMessageDecoder());//加入解码器
        pipeline.addLast(new MyClientHandler());
    }
}


    package com.feng.netty.protocoltcp;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import java.nio.charset.Charset;


public class MyClientHandler extends SimpleChannelInboundHandler<MessageProtocol> {
    private int count;
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //使用客户端发送10条数据，"今天天气冷，吃火锅" 编号
        for (int i=0;i<5;i++){
            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);
        }
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, MessageProtocol msg) throws Exception {

        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));
    }


    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("异常消息="+cause.getMessage());
        ctx.close();
    }
}
IT小学僧
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用Netty解决TCP粘包和拆包问题过程详解
08-25
主要介绍了使用Netty解决TCP粘包和拆包问题过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Golang TCP粘包拆包问题的解决方法
01-03
什么是粘包问题 最近在使用Golang编写Socket层，发现有时候接收端会一次读到多个数据包的问题。于是通过查阅资料，发现这个就是传说中的TCP粘包问题。下面通过编写代码来重现这个问题： 服务端代码 server/main.go func main() { l, err := net.Listen(tcp, :4044) if err != nil { panic(err) } fmt.Println(listen to 4044) for { // 监听到新的连接，创建新的 goroutine 交给 handleConn函数 处理 conn, er
Netty 解决粘包和拆包问题的四种方案
最新发布
weixin_44749255的博客
02-29 1487
Netty 解决粘包和拆包问题的四种方案
c#tcp 粘包拆包解决方法，包头加数据长度
05-11
发生TCP粘包或拆包有很多原因，现列出常见的几点，可能不全面，欢迎补充， 1、要发送的数据大于TCP发送缓冲区剩余空间大小，将会发生拆包。 2、待发送数据大于MSS（最大报文长度），TCP在传输前将进行拆包。 3、要发送的数据小于TCP发送缓冲区的大小，TCP将多次写入缓冲区的数据一次发送出去，将会发生粘包。 4、接收数据端的应用层没有及时读取接收缓冲区中的数据，将发生粘包。
解决TCP粘包/拆包问题的方法及示例
polsnet的专栏
05-11 3109
还有一种解决TCP粘包/拆包问题的方法是使用定长协议，即规定每次发送的数据包都是固定长度，例如规定每次发送的数据包长度为固定的100个字节，如果发送的数据长度不足100字节，则在后面填充空格或者其他特定字符，如果超过100字节，则进行截断处理。由于网络的不可靠性，TCP为了提高传输效率，会将多个小数据块打包成一个大的数据块一起发送（称为TCP粘包），或者将一个大的数据块拆分成多个小的数据块发送（称为TCP拆包）。由于TCP是面向流的协议，发送的数据流会被自动分段，可能出现多个短消息被粘在一起发送的情况。
TCP 的粘包和拆包以及解决方案
a549654065的博客
03-31 999
TCP 是一个传输协议。TCP 在发送数据的时候，往往不会将数据一次性发送。如下所示：而是将数据拆分成很多个部分，然后再逐个发送。像下图这样：那么为什么 TCP 协议不一次性发完所有的数据？比如我们要传一个大小为 10M 的文件，对于应用层而言，就是一次传送完成的。而传输层的协议为什么不选择将这个文件一次发送完呢？首先这个有很多原因，比如为了稳定，降低整体任务出错的概率，以及减小底层网络处理的压力，再比如说为了效率，网络中有时候存在着并行的路径，拆分数据包就能更好地利用这些并行的路径。
TCP粘包和拆包问题及其解决方法
AGangyaa的博客
11-13 4456
TCP粘包和拆包问题及其解决方法
TCP粘包与拆包问题及解决方案
zouke314的博客
06-07 5271
1、在RPC框架中，TCP粘包和拆包问题是必须解决一个问题，因为RPC框架中，各个微服务相互之间都是维系了一个TCP长连接，比如dubbo就是一个全双工的长连接。由于微服务往对方发送信息的时候，所有的请求都是使用的同一个连接，这样就会产生粘包和拆包的问题。 ...
TCP中的粘包、拆包问题产生原因及解决方法
梦~'
04-22 7786
粘包/拆包 问题产生原因： 发生TCP粘包或拆包有很多原因，现列出常见的几点： 要发送的数据大于TCP发送缓冲区剩余空间大小，将会发生拆包。 待发送数据大于MSS（TCP报文长度 - TCP头部长度 > MSS最大报文长度），TCP在传输前将根据MSS大小进行拆包分段发送。 要发送的数据小于TCP发送缓冲区的大小，TCP将多次写入缓冲区的数据包合并为一次发送，将发生粘包（Nagle算法优化，避免tcp报文头重脚轻的情况发生） 接收数据端的应用层没有及时读取接收缓冲区中的数据，将发生粘包。
TCP粘包/拆包问题的解决方法
weixin_42574365的博客
07-26 1186
1.什么是TCP的粘包/拆包 TCP的粘包和拆包，指的是上层同一个业务逻辑中的数据可能再发送过程中被TCP拆成多个包，或多个小包连成一个大包发送出去，从而导致业务处理逻辑出错的问题。 造成TCP粘包/拆包的原因： 应用程序写入的字节长度大于发送缓冲区大小； 进行MSS大小的TCP分段； 以以太帧的payload大于MTU进行IP分片。 2.怎么解决粘包/拆包问题 3.粘包/拆包问题案例 4.使用Netty解决粘包/拆包问题 ...
TCP 拆包和粘包原因及解决方案
谈谈1974
06-16 3265
文章目录1. 拆包和粘包的概念2. 产生拆包和粘包的原因3. 解决方案 1. 拆包和粘包的概念 2. 产生拆包和粘包的原因 3. 解决方案
【QT】自定义协议解决TCP粘包和拆包问题
08-11
本demo模拟了TCP通信中发送端和接收端的行为，并利用序列化和反序列化的思想，自定义协议来解决TCP的粘包和拆包问题。
TCP粘包/拆包及解决方法
weixin_42579072的博客
01-06 690
我想先举两个简单的应用场景： 1）客户端和服务器建立一个连接，客户端发送一条消息，客户端关闭与服务端的连接。 2）客户端和服务器简历一个连接，客户端连续发送两条消息，客户端关闭与服务端的连接。 对于第一种情况，服务端的处理流程可以是这样的：当客户端与服务端的连接建立成功之后，服务端不断读取客户端发送过来的数据，当客户端与服务端连接断开之后，服务端知道已经读完了一条消息，然后进行解码和后续处理…。 ...
简单易懂的Socket TCP网络通讯知识-粘包，拆包，包体长度的意义
神一般的狄狄的小黑屋
12-06 582
粘包 和 拆包 百度一下很多文章都有解释的 链接: MSS. MTU. 原因的话，就是网络层级故意给你搞的。 TCP下，也没啥必要纠结这一块东西。 简单来说，就是 粘包就是 接收端一次收到2个包 拆包 就是 接收端里 有一个包不完整，只有一部分。 拆包 和 粘包 可能混合出现。 解决这个问题最好的办法，其实就是 数据包 有长度。 按照长度去获取 数据包，发现包体不完整，就等下一次Check。 例如 完整数据包 + 破损数据包（粘包 + 拆包，经常出现 很正常） 破损数据包（拆包，可能是你缓冲区太小了，单个数
TCP粘包，拆包及解决方法
猛犸象
07-01 4330
在进行Java NIO学习时，发现，如果客户端连续不断的向服务端发送数据包时，服务端接收的数据会出现两个数据包粘在一起的情况，这就是TCP协议中经常会遇到的粘包以及拆包的问题。 我们都知道TCP属于传输层的协议，传输层除了有TCP协议外还有UDP协议。那么UDP是否会发生粘包或拆包的现象呢？答案是不会。UDP是基于报文发送的，从UDP的帧结构可以看出，在UDP首部采用了16bit来指示UDP数据报文的长度，因此在应用层能很好的将不同的数据报文区分开，从而避免粘包和拆包的问题。而TCP是基于字节流的，虽然应用
TCP如何解决粘包
居老师的博客
04-23 5916
如何解决粘包？ 粘包的问题出现是因为不知道一个用户消息的边界在哪，如果知道了边界在哪，接收方就可以通过边界来划分出有效的用户消息。 一般有三种方式分包的方式： 固定长度的消息； 特殊字符作为边界； 自定义消息结构。 #固定长度的消息 这种是最简单方法，即每个用户消息都是固定长度的，比如规定一个消息的长度是 64 个字节，当接收方接满 64 个字节，就认为这个内容是一个完整且有效的消息。 但是这种方式灵活性不高，实际中很少用。 #特殊字符作为边界 我们可以在两个用户消息之间插入一个特殊的字符
13、TCP 粘包和拆包及解决方案
m0_45364328的博客
05-21 710
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录TCP 粘包和拆包基本介绍TCP 粘包和拆包现象实例netty解决 TCP 粘包和拆包解决方案看一个具体的实例: TCP 粘包和拆包基本介绍 TCP是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端） 都要有一一成对的socket，因此，发送端为了将多个发给接收端的包，更有效的发 给对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合 并成一个大的数据块，然后进行封包。这样做虽然提高了效.
TCP粘包问题
罗布泊coding
07-06 887
TCP是面向流的协议，流就像河流中的水，一个字节一个字节地发送，本身是不存在独立包的，包与包之间没有界限，所以会产生粘包现象。而UDP是基于数据报的协议，它有消息边界，不会出现粘包现象。一． 什么是粘包现象　　TCP粘包是指发送方发送的若干包数据到接收方接收时粘成一包，从接收缓冲区看，后一包数据的头紧接着前一包数据的尾。例如： 如果双方建立连接，需要在连接后一段时间内发送不同结构数据，如连接后，有
TCP粘包问题以及解决方法
cpxsxn的博客
09-19 3465
这是因为接收方先把收到的数据放在系统接收缓冲区，用户进程从该缓冲区取数据，若下一包数据到达时前一包数据尚未被用户进程取走，则下一包数据放到系统接收缓冲区时就接到前一包数据之后，而用户进程根据预先设定的缓冲区大小从系统接收缓冲区取数据，这样就一次取到了多包数据。可以将真实数据，做成一个固定长度的报头，客户端发送给服务端，服务端可以接受报头，然后对报头进行解包，获取真实数据的长度，进行接收即可。TCP粘包是指发送方发送的若干包数据到接收方接收时粘成一包，从接收缓冲区看，后一包数据的头紧接着前一包数据的尾。
tcp粘包和拆包解决方案
03-08
TCP粘包和拆包的解决方案有以下几种： 1.消息定长：发送方将消息固定长度发送，接收方按照固定长度接收，不足的补齐，多余的截断。 2.特殊字符分隔：发送方在消息末尾添加特殊字符，接收方根据特殊字符进行消息分割...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值