深刻解读网络通信中丢包粘包问题

最新推荐文章于 2024-10-29 21:11:00 发布

DRen1

最新推荐文章于 2024-10-29 21:11:00 发布

阅读量737

点赞数 1

分类专栏：计算机网络文章标签：网络计算机网络

本文链接：https://blog.csdn.net/qq_43237354/article/details/132074569

版权

计算机网络专栏收录该内容

1 篇文章 0 订阅

订阅专栏

关于丢包粘包的问题，经过一番资料查找，以下面的回答作为总结：

首先解释下tcp 协议

TCP（Transmission Control Protocol）是一种流式协议（Stream Protocol）。TCP是一种面向连接的协议，它负责在网络中可靠地传输数据。在TCP连接中，数据被视为连续的字节流，而不是分割成固定大小的数据包或数据块。

TCP将应用层传递给它的数据视为一个字节流，然后将这个字节流分割成称为TCP报文段（TCP Segment）的小数据块，这些报文段被用于在网络中传输。在接收方，TCP负责将接收到的TCP报文段重新组装成连续的字节流，并交给上层应用程序处理。

由于TCP是面向连接的协议，通信的双方需要在建立连接之后进行数据传输。在TCP连接中，数据的传输是有序的和可靠的，TCP会通过序列号和确认机制来确保数据的完整性和顺序。如果接收方在一段时间内没有收到期望的数据段，它会发送一个确认来请求重传丢失的数据，确保数据的可靠性。

在网络通信中，解释丢包（Packet Loss）和粘包（Packet Proliferation）问题，它们分别指代以下情况：

丢包（Packet Loss）：丢包是指在数据传输过程中，部分数据包在网络中丢失，未能到达目标节点。这可能是由于网络拥塞、传输错误、网络故障或其他因素导致的。当数据包丢失时，接收方无法收到完整的数据，可能会导致数据不完整或操作失败。在TCP协议中，当发生丢包时，TCP会通过重传机制来确保数据的可靠传输，但这可能会导致传输延迟。
粘包（Packet Proliferation）：粘包是指在数据传输过程中，多个数据包在网络中的某个节点被合并成一个更大的数据包，从而导致接收方一次性接收到多个数据包。这可能是由于网络缓冲区、传输优化算法（如Nagle算法）等因素导致的。当接收方收到粘包时，可能会导致数据解析错误或数据处理不完整。

举例来说，假设有两个应用程序A和B在进行网络通信，A向B发送两个独立的数据包（Packet 1和Packet 2），但由于网络缓冲区的影响，这两个数据包在传输过程中被合并成一个较大的数据包（即粘包），到达B时，B会一次性收到这两个数据包，而不是分开接收。另一方面，如果在传输过程中，Packet 1由于网络问题丢失了，那么B将只能接收到Packet 2（即丢包）。

首先回答丢包问题：

这个并不需要我们来解决，因为这个和tcp协议自身相关，我们程序开发几乎不会触碰这个问题。

再回答粘包问题：

首先，什么叫“包”？

在基于tcp开发应用的语境下，其实有两种“包”，其一是tcp在传输的时候封装的报文，分为包头和负载，其二是应用开发者在应用层封装的报文结构。

第二，什么叫“粘包”？TCP的粘包解释如下。

TCP粘包是指在tcp传输时，用户发送的包连同下一个tcp应用层数据包粘在一起被客户接受，导致用户收到的包，不是不完整的，就是涵盖了下一个包的畸形数据（或者是缺失数据叫做半包），导致数据处理出现问题。

为什么会出现粘包？

因为Nagle算法！

具体来说，Nagle算法的工作过程如下：

发送数据：当应用程序想要发送小数据包时，TCP栈并不立即发送该数据包，而是将其缓存起来。
检查延迟ACK：TCP会检查是否已经收到来自接收方的确认ACK（Acknowledgment）信号。如果已经收到确认，说明之前发送的数据已经被接收方正确处理，TCP会立即发送新的数据。
延迟ACK等待：如果TCP还没有收到接收方的确认ACK，它会等待一小段时间，通常是200毫秒左右。这样做是为了等待之前发送的数据到达接收方并得到确认，以确保不会发送过多的小数据包。
数据合并：在等待ACK的过程中，如果应用程序继续产生新的小数据包，TCP会将这些小数据包合并为一个大的数据包。
发送数据：一旦延迟时间到达或者合并的数据包达到一定大小，TCP就会发送该数据包到接收方。

总的来说，Nagle算法通过延迟发送小数据包，并合并多个小数据包，从而有效地减少了网络传输的次数，降低了网络拥塞问题。然而，Nagle算法在一些特定情况下可能会导致延迟增加，例如在某些交互式应用或实时通信场景下。因此，一些应用程序可能会通过设置TCP_NODELAY选项来禁用Nagle算法，以提高实时性和降低延迟。

Nagle算法引入了一定的延迟，因为它需要等待之前发送的数据被确认ACK之后，才会发送新的数据。这种等待是为了确保不会发送过多的小数据包。在某些特定场景下，这种延迟可能会影响实时通信应用的性能，因为它要求即时的数据传输和低延迟。

因此，在实时通信应用中，一些开发者可能会考虑禁用Nagle算法，以牺牲一定的网络传输效率来换取更低的延迟。禁用Nagle算法后，虽然可以减少延迟，但也可能导致网络拥塞和带宽利用率下降的问题。所以在实际应用中，需要权衡利弊，根据具体需求做出选择。

那么我们如何解决粘包呢？

解决方法很简单，就是使用基于流缓冲区数据接受方式，然后配合序列化/反序列化框架，来进行包解析，通过在应用层的协议中放置的特定包起始头，来判断包的长度，并进行接受和解析。需要设计一个带包头的应用层报文结构包头定长，以特定标志开头，里带着负载长度，这样接收侧只要以定长尝试读取包头，再按照包头里的负载长度读取负载就行了，多出来的数据都留在缓冲区里即可。应用层协议可以参考http协议。

举个例子，使用Java中的netty 框架，用ByteBuf来获取数据，然后可以自定义解析规则来解析数据，相当于自己重写一个简单的应用层协议。我编写的基于Netty框架，解码tcp传来的数据，示例代码如下：

public class MeaasgeDecoder extends ByteToMessageDecoder {

    @Override
    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf in, List<Object> out) throws Exception {
        //readBytes(byte[] dst)
        //参数：dst - 目标字节数组，用于存储从ByteBuf中读取的字节数据。
        //功能：从ByteBuf中将指定长度的字节数据读取到目标字节数组dst中。
        //返回值：无。
        //注意：dst字节数组必须具有足够的容量来存储读取的字节数据，否则可能会导致IndexOutOfBoundsException异常。
        if(in.readableBytes() < 28){//数据量不够，等待下一次读取
            return;
        }
        Message message = ByteBufToMessageUtils.transition(in);
        if(message == null){
            System.out.println("message is null,解析失败");
            return;
        }
        out.add(message);
    }
}

public class ByteBufToMessageUtils {

    public static Message transition(ByteBuf in){

        /** 获取command*/
        int command = in.readInt();

        /** 获取version*/
        int version = in.readInt();

        /** 获取clientType*/
        int clientType = in.readInt();

        /** 获取mesageType*/
        int messageType = in.readInt();

        /** 获取appId*/
        int appId = in.readInt();

        /** 获取imeiLength*/
        int imeiLength = in.readInt();

        /** 获取bodyLen*/
        int bodyLen = in.readInt();

        if(in.readableBytes() < bodyLen + imeiLength){//如果可读的字节数小于bodyLen + imeiLength，说明数据可能不完整，有拆包粘包
            in.resetReaderIndex();
            return null;
        }

        byte [] imeiData = new byte[imeiLength];
        in.readBytes(imeiData);
        String imei = new String(imeiData);

        byte [] bodyData = new byte[bodyLen];
        in.readBytes(bodyData);


        MessageHeader messageHeader = new MessageHeader();
        messageHeader.setAppId(appId);
        messageHeader.setClientType(clientType);
        messageHeader.setCommand(command);
        messageHeader.setLength(bodyLen);
        messageHeader.setVersion(version);
        messageHeader.setMessageType(messageType);
        messageHeader.setImei(imei);
        messageHeader.setImeiLength(imeiLength);

        Message message = new Message();
        message.setMessageHeader(messageHeader);

        if(messageType == 0x0){
            String body = new String(bodyData);
            JSONObject parse = (JSONObject) JSONObject.parse(body);
            message.setMessagePack(parse);
        }

        in.markReaderIndex();
        return message;
    }

}