解决tcp粘包问题

目录

什么是粘包(演示粘包现象)

解决粘包

实际应用

什么是粘包

首先只有tcp有粘包现象，udp没有粘包

socket收发消息的原理

发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节<br>的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束。

粘包问题的根源

所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

tcp和udp协议

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。

UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。

tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，实验略。

补充

拆包的发生情况

当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。

补充问题一：为何tcp是可靠传输，udp是不可靠传输

tcp在数据传输时，发送端先把数据发送到自己的缓存中，然后协议控制将缓存中的数据发往对端，对端返回一个ack=1，发送端则清理缓存中的数据，对端返回ack=0，则重新发送数据，所以tcp是可靠的。

而udp发送数据，对端是不会返回确认信息的，因此不可靠。

补充问题二：send(字节流)和recv(1024)及sendall

recv里指定的1024意思是从缓存里一次拿出1024个字节的数据

send的字节流是先放入己端缓存，然后由协议控制将缓存内容发往对端，如果待发送的字节流大小大于缓存剩余空间，那么数据丢失，用sendall就会循环调用send，数据不会丢失。

总结

udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠。

tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

演示粘包现象

两种情况下会发生粘包

发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据量很小，会合到一起，产生粘包），这是由于tcp的优化算法。

接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

第一种情况：

客户端多次间隔时间短，数据量小的发送数据

  1 #服务端
  2 import socket
  3
  4 def main():
  5     ip_port= ('127.0.0.1',4444)
  6     back_log=5
  7     buffer_size=1024
  8
  9     s1 = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #基于tcp的网络通信
 10     s1.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
 11     s1.bind(ip_port) #绑定ip和端口
 12     s1.listen(back_log)  # 最多连接几个客户端
 13     conn, addr = s1.accept()
 14
 15     data1=conn.recv(buffer_size)
 16     data2=conn.recv(buffer_size)
 17     data3=conn.recv(buffer_size)
 18     print('第一次',data1.decode('utf-8'))
 19     print('第二次',data2.decode('utf-8'))
 20     print('第三次',data3.decode('utf-8'))
 21     conn.close()
 22     s1.close()
 23
 24 if __name__ == '__main__':
 25     main()
 26
 27
 28 #客户端
 29 import socket
 30
 31 def main():
 32     ip_port = ('127.0.0.1', 4444)
 33
 34     buffer_size = 1024
 35
 36     s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 37
 38     s2.connect(ip_port)  # 连接服务端
 39
 40     data1 = 'hello'
 41     s2.send(data1.encode('utf-8'))
 42     data2 ='wrold'
 43     s2.send(data2.encode('utf-8'))
 44     data3 = 'pop'
 45     s2.send(data3.encode('utf-8'))
 46     s2.close()
 47
 48 if __name__ == '__main__':
 49     main()
 50 

演示

可以看出来服务端在第一次就把三次发送的数据都接收了，这就是粘包，服务端不知道一次读取多少的数据，一次全部读取出来。

首先我们要知道并不是客户端发几次，服务端就要接收几次，一次发的数据也可以三次读取出来，收发信息都是从自己的内核缓存区读取。

第二种情况：

接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

  1 #服务端
  2 import socket
  3
  4 def main():
  5     ip_port= ('127.0.0.1',4444)
  6     back_log=5
  7     buffer_size=1024
  8
  9     s1 = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #基于tcp的网络通信
 10     s1.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
 11     s1.bind(ip_port) #绑定ip和端口
 12     s1.listen(back_log)  # 最多连接几个客户端
 13     conn, addr = s1.accept()
 14
 15     data1=conn.recv(5)
 16     data2=conn.recv(buffer_size)
 17
 18     print('第一次',data1.decode('utf-8'))
 19     print('第二次',data2.decode('utf-8'))
 20
 21     conn.close()
 22     s1.close()
 23
 24 if __name__ == '__main__':
 25     main()
 26
 27
 28 #客户端
 29 import socket
 30
 31 def main():
 32     ip_port = ('127.0.0.1', 4444)
 33
 34     s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 35
 36     s2.connect(ip_port)  # 连接服务端
 37
 38     data1 = 'hellowroldpop'
 39     s2.send(data1.encode('utf-8'))
 40     s2.close()
 41
 42 if __name__ == '__main__':
 43     main()

演示

服务端读取数据没有全部读取出来，导致第一次应该接收完的数据还要第二次读取出来。

解决粘包

问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据

第一种解决方法

  1 #服务端
  2 import socket
  3
  4 def main():
  5     ip_port = ('127.0.0.1', 4444)
  6     back_log = 5
  7     buffer_size = 1024
  8
  9     s1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 基于tcp的网络通信
 10     s1.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 11     s1.bind(ip_port)  # 绑定ip和端口
 12     s1.listen(back_log)  # 最多连接几个客户端
 13     conn, addr = s1.accept()
 14
 15     while True:
 16 　　　　 #接收数据大小
 17         length= conn.recv(buffer_size).decode('utf-8')<br>　　　　 #为防止客户端连续发包，回应
 18         conn.send('ready'.encode('utf-8'))
 19         length=int(length)
 20
 21         recv_size=0   #已经接收到数据的大小
 22         recv_msg=b''  #已经接收到的数据<br>
 23 　　　　 #接收数据
 24         while recv_size<length:
 25             r_msg = conn.recv(buffer_size)
 26             recv_msg+=r_msg
 27             recv_size +=len(r_msg)
 28 　　　　　　　#另一种方法接收数据的方法<br>
 29             #recv_msg+=conn.recv(buffer_size)
 30             #recv_size=len(recv_msg)
 31
 32     s1.close()
 33
 34 if __name__ == '__main__':
 35     main()
 36
 37
 38
 39 #客户端
 40 import socket
 41
 42 def main():
 43     ip_port = ('127.0.0.1', 4444)
 44
 45     buffer_size = 1024
 46
 47     s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 48
 49     s2.connect(ip_port)  # 连接服务端
 50
 51     while True:
 52
 53         data1 = input('input:')<br>　　　　　#将数据大小转为字符型然后编码发出去
 54         s2.send(str(len(data1)).encode('utf-8'))<br>　　　　　　#接收服务端的回应
 55         server_Ready=s2.recv(buffer_size)<br>　　　　　　#接收到服务端回应
 56         if server_Ready==b'ready':
 57             s2.send(data1.encode('utf-8'))
 58     s2.close()
 59
 60
 61 if __name__ == '__main__':
 62     main()
 63 

总结：客户端在发送数据时，先发送数据大小，这时不能把数据内容一起发送出去，服务端第一次接收的时候，并不知道该读取多少的数据大小和多少的数据内容，所以还是会造成粘包，我们的解决办法是，服务端获取到数据大小后，要回应一次，然后根据数据大小来循环读取内容。

这种方法不好，需要服务端多发一次回应，这很影响服务端的性能。

程序的运行速度远快于网络传输速度，所以在发送一段字节前，先用send去发送该字节流长度，这种方式会放大网络延迟带来的性能损耗。

第二种解决方法

为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据

struct模块

该模块可以把一个类型，如数字，转成固定长度的bytes

>>> struct.pack('i',1111111111111) #第一个参数是要封装的格式类型，第二个参数是要封装的内容

struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #这个封装数据的范围，只要在这个范围里面，就可以把内容封装成固定大小

  1 #服务端
  2
  3 import socket
  4 import struct
  5
  6 def main():
  7     ip_port = ('127.0.0.1', 4444)
  8     back_log = 5
  9     buffer_size = 1024
 10
 11     s1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 基于tcp的网络通信
 12     s1.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 13     s1.bind(ip_port)  # 绑定ip和端口
 14     s1.listen(back_log)  # 最多连接几个客户端
 15     conn, addr = s1.accept()
 16
 17     while True:
 18
 19         length＿data= conn.recv(4)
 20         length=struct.unpack('i',length＿data)[0]
 21
 22         recv_size=0   #已经接收到数据的大小
 23         recv_msg=b''  #已经接收到的数据
 24
 25         while recv_size<length:
 26             r_msg = conn.recv(buffer_size)
 27             recv_msg+=r_msg
 28             recv_size +=len(r_msg)
 29
 30             #recv_msg+=conn.recv(buffer_size)
 31             #recv_size=len(recv_msg)
 32
 33
 34     s1.close()
 35
 36
 37 if __name__ == '__main__':
 38     main()
 39
 40
 41 #客户端
 42
 43 import socket
 44 import struct
 45
 46 def main():
 47     ip_port = ('127.0.0.1', 4444)
 48
 49     buffer_size = 1024
 50
 51     s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 52
 53     s2.connect(ip_port)  # 连接服务端
 54
 55     while True:
 56
 57         data1 = input('input:')
 58         length=len(data1)
 59         #定制包头 i为4个字节，所以接收方为四个字节，这个大小并不是输入的大小，而是封装固定的大小
 60         data_length=struct.pack('i',length) #使用struct，直接将int转为二进制型数据传输，对方使用struct解包
 61         s2.send(data_length)
 62
 63         s2.send(data1.encode('utf-8'))
 64     s2.close()
 65
 66 if __name__ == '__main__':
 67     main()

总结：客户端把数据长度封装成一个固定大小的数据，这时服务端就可以指定读取固定大小的内容，不会读取数据的内容，服务端只要根据数据长度再来接收数据内容就好了，所以客户端连续两次发数据，不会粘包，因为服务端每次接收都只接收了本次该接收的数据。

实际应用

#服务端
from socket import  *
import subprocess
import struct

def main():
    ip_port=('127.0.0.1',8080)
    back_log=5
    buffer_size=1024

    s1 = socket(AF_INET,SOCK_STREAM)
    s1.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
    s1.bind(ip_port)
    s1.listen(back_log)

    while True:
        conn,addr=s1.accept()

        while True:
            try:
                #收信息
                 cmd = conn.recv(buffer_size)
                 if not cmd:break
                 print('收到的命令是:',cmd.decode('utf-8'))

                 #执行命令
                 res = subprocess.Popen(cmd.decode('utf-8'),shell=True,
                                        stderr=subprocess.PIPE,
                                        stdout=subprocess.PIPE,
                                        stdin=subprocess.PIPE)

                 err = res.stderr.read()
                 if  err:
                     cmd_res=err
                 else:
                     cmd_res=res.stdout.read()

                 if not cmd_res:
                     cmd_res='执行成功'.encode('gbk')

                 length=len(cmd_res)
                #第一次发送数据大小
                 data_length = struct.pack('i', length)  # 使用struct，直接将int转为二进制型数据传输，对方使用struct解包
                 conn.send(data_length)
                #发信息
                #注意：执行的结果默认jbk编码方式,所以客户端必须使用gbk方式解码
                 conn.send(cmd_res)

            except Exception:
                break
        conn.close()
    s1.close()  # 关闭服务端套接字

if __name__ == '__main__':
    main()

#客户端
from socket import  *
import struct

def main():
    ip_port=('127.0.0.1',8080)
    buffer_size=1024

    s1 = socket(AF_INET,SOCK_STREAM)
    s1.connect(ip_port)

    while True:
        cmd = input('-->')
        if not cmd:continue
        if cmd =='quite':break
        s1.send(cmd.encode('utf-8'))
        length＿data =s1.recv(4)
        length = struct.unpack('i', length＿data)[0]

        recv_size = 0  # 已经接收到数据的大小
        recv_msg = b''  # 已经接收到的数据

        while recv_size < length:
            r_msg = s1.recv(buffer_size)
            recv_msg += r_msg
            recv_size += len(r_msg)

            # recv_msg+=conn.recv(buffer_size)
            # recv_size=len(recv_msg)

        print('命令执行结果:',recv_msg.decode('gbk'))

    s1.close()

if __name__=='__main__':
    main()

总结

如果没有粘包的处理，服务端把命令执行的结果发给客户端的时候，数据太大，客户端一次没有接收完，在客户端第二次执行命令的时候，就会把第一次没有读取完的部分也读取出来，这属于我们刚才说的第二种粘包的情况。

有了粘包的处理，只要服务端把结果发过来，就算超过网卡的限制（拆包发送），客户端能保证在循环的过程中接收完结果。

转载链接：https://www.cnblogs.com/-wenli/p/10178436.html