2023年7月15日发(作者：)

python套接字解决tcp粘包问题python套接字解决tcp粘包问题⽬录什么是粘包演⽰粘包现象解决粘包实际应⽤

什么是粘包⾸先只有tcp有粘包现象，udp没有粘包

socket收发消息的原理

发送端可以是⼀K⼀K地发送数据，⽽接收端的应⽤程序可以两K两K地提⾛数据，当然也有可能⼀次提⾛3K或6K数据，或者⼀次只提⾛⼏个字节的数据，也就是说，应⽤程序所看到的数据是⼀个整体，或说是⼀个流（stream），⼀条消息有多少字节对应⽤程序是不可见的，因此TCP协议是⾯向流的协议，这也是容易出现粘包问题的原因。⽽UDP是⾯向消息的协议，每个UDP段都是⼀条消息，应⽤程序必须以消息为单位提取数据，不能⼀次提取任意字节的数据，这⼀点和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的数据传输请参考另⼀篇⽂章/linhaifeng/articles/，tcp在数据传输时，发送端先把数据发送到⾃⼰的缓存中，然后协议控制将缓存中的数据发往对端，对端返回⼀个ack=1，发送端则清理缓存中的数据，对端返回ack=0，则重新发送数据，所以tcp是可靠的⽽udp发送数据，对端是不会返回确认信息的，因此不可靠补充问题⼆：send(字节流)和recv(1024)及sendallrecv⾥指定的1024意思是从缓存⾥⼀次拿出1024个字节的数据send的字节流是先放⼊⼰端缓存，然后由协议控制将缓存内容发往对端，如果待发送的字节流⼤⼩⼤于缓存剩余空间，那么数据丢失，⽤sendall就会循环调⽤send，数据不会丢失　　

总结udp的recvfrom是阻塞的，⼀个recvfrom(x)必须对唯⼀⼀个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，⼰端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。　　

演⽰粘包现象 两种情况下会发⽣粘包发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据量很⼩，会合到⼀起，产⽣粘包），这是由于tcp的优化算法。接收⽅不及时接收缓冲区的包，造成多个包接收（客户端发送了⼀段数据，服务端只收了⼀⼩部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产⽣粘包）

第⼀种情况客户端多次间隔时间短，数据量⼩的发送数据#服务端import socketdef main(): ip_port= ('127.0.0.1',4444) back_log=5 buffer_size=1024 s1 = (_INET,_STREAM) #基于tcp的⽹络通信 kopt(_SOCKET,_REUSEADDR,1) (ip_port) #绑定ip和端⼝ (back_log) # 最多连接⼏个客户端 conn, addr = () data1=(buffer_size) data2=(buffer_size) data3=(buffer_size) print('第⼀次',('utf-8')) print('第⼆次',('utf-8')) print('第三次',('utf-8')) () ()if __name__ == '__main__': main()　#客户端import socketdef main(): ip_port = ('127.0.0.1', 4444) buffer_size = 1024 s2 = (_INET, _STREAM) t(ip_port) # 连接服务端 data1 = 'hello' (('utf-8')) data2 ='wrold' (('utf-8')) data3 = 'pop' (('utf-8')) ()if __name__ == '__main__': main()

演⽰可以看出来服务端在第⼀次就把三次发送的数据都接收了，这就是粘包，服务端不知道⼀次读取多少的数据，⼀次全部读取出来。⾸先我们要知道并不是客户端发⼏次，服务端就要接收⼏次，⼀次发的数据也可以三次读取出来，收发信息都是从⾃⼰的内核缓存区读取。

第⼆种情况接收⽅不及时接收缓冲区的包，造成多个包接收（客户端发送了⼀段数据，服务端只收了⼀⼩部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产⽣粘包）

#服务端import socketdef main(): ip_port= ('127.0.0.1',4444) back_log=5 buffer_size=1024 s1 = (_INET,_STREAM) #基于tcp的⽹络通信 kopt(_SOCKET,_REUSEADDR,1) (ip_port) #绑定ip和端⼝ (back_log) # 最多连接⼏个客户端 conn, addr = () data1=(5) data2=(buffer_size)

print('第⼀次',('utf-8')) print('第⼆次',('utf-8'))

() ()if __name__ == '__main__': main()#客户端import socketdef main(): ip_port = ('127.0.0.1', 4444)

s2 = (_INET, _STREAM) t(ip_port) # 连接服务端 data1 = 'hellowroldpop' (('utf-8')) ()if __name__ == '__main__': main()

演⽰服务端读取数据没有全部读取出来，导致第⼀次应该接收完的数据还要第⼆次读取出来

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

第⼀种解决⽅法#服务端import socketdef main(): ip_port = ('127.0.0.1', 4444) back_log = 5 buffer_size = 1024 s1 = (_INET, _STREAM) # 基于tcp的⽹络通信 kopt(_SOCKET, _REUSEADDR, 1) (ip_port) # 绑定ip和端⼝ (back_log) # 最多连接⼏个客户端 conn, addr = () while True:　　　　 #接收数据⼤⼩ length= (buffer_size).decode('utf-8')　　　　 #为防⽌客户端连续发包，回应 ('ready'.encode('utf-8')) length=int(length) recv_size=0 #已经接收到数据的⼤⼩ recv_msg=b'' #已经接收到的数据　　　　 #接收数据 while recv_size

recv_msg+=r_msg recv_size +=len(r_msg)　　　　　　　#另⼀种⽅法接收数据的⽅法 #recv_msg+=(buffer_size) #recv_size=len(recv_msg) ()if __name__ == '__main__': main()　

#客户端import socketdef main(): ip_port = ('127.0.0.1', 4444) buffer_size = 1024 s2 = (_INET, _STREAM) t(ip_port) # 连接服务端 while True: data1 = input('input:')　　　　　#将数据⼤⼩转为字符型然后编码发出去 (str(len(data1)).encode('utf-8'))　　　　　　#接收服务端的回应 server_Ready=(buffer_size)　　　　　　#接收到服务端回应 if server_Ready==b'ready': (('utf-8')) ()if __name__ == '__main__': main()　 总结：客户端在发送数据时，先发送数据⼤⼩，这时不能把数据内容⼀起发送出去，服务端第⼀次接收的时候，并不知道该读取多少的数据⼤⼩和多少的数据内容，所以还是会造成粘包，我们的解决办法是，服务端获取到数据⼤⼩后，要回应⼀次，这种⽅法不好，需要服务端多发⼀次回应，这很影响服务端的性能。程序的运⾏速度远快于⽹络传输速度，所以在发送⼀段字节前，先⽤send去发送该字节流长度，这种⽅式会放⼤⽹络延迟带来的性能损耗　　

第⼆种解决⽅法为字节流加上⾃定义固定长度报头，报头中包含字节流长度，然后⼀次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据

struct模块

该模块可以把⼀个类型，如数字，转成固定长度的bytes>>> ('i',11) #第⼀个参数是要封装的格式类型，第⼆个参数是要封装的内容: 'i' format requires -2147483648 <= number <= 2147483647 #这个封装数据的范围，只要在这个范围⾥⾯，就可以把内容封装成固定⼤⼩

#服务端import socketimport structdef main(): ip_port = ('127.0.0.1', 4444) back_log = 5 buffer_size = 1024 s1 = (_INET, _STREAM) # 基于tcp的⽹络通信 kopt(_SOCKET, _REUSEADDR, 1) (ip_port) # 绑定ip和端⼝ (back_log) # 最多连接⼏个客户端 conn, addr = () while True: length＿data= (4) length=('i',length＿data)[0] recv_size=0 #已经接收到数据的⼤⼩ recv_msg=b'' #已经接收到的数据 while recv_size

#客户端import socketimport structdef main(): ip_port = ('127.0.0.1', 4444) buffer_size = 1024 s2 = (_INET, _STREAM) t(ip_port) # 连接服务端 while True: data1 = input('input:') length=len(data1) #定制包头 i为4个字节，所以接收⽅为四个字节，这个⼤⼩并不是输⼊的⼤⼩，⽽是封装固定的⼤⼩ data_length=('i',length) #使⽤struct，直接将int转为⼆进制型数据传输，对⽅使⽤struct解包 (data_length) (('utf-8')) ()if __name__ == '__main__': main()　　

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

实际应⽤

#服务端from socket import *import subprocessimport structdef main(): ip_port=('127.0.0.1',8080) back_log=5 buffer_size=1024 s1 = socket(AF_INET,SOCK_STREAM) kopt(SOL_SOCKET, SO_REUSEADDR, 1) (ip_port) (back_log) while True: conn,addr=() while True: try: #收信息 cmd = (buffer_size) if not cmd:break print('收到的命令是:',('utf-8')) #执⾏命令 res = (('utf-8'),shell=True, stderr=, stdout=, stdin=) err = () if err: cmd_res=err else: cmd_res=() if not cmd_res: cmd_res='执⾏成功'.encode('gbk') length=len(cmd_res) #第⼀次发送数据⼤⼩ data_length = ('i', length) # 使⽤struct，直接将int转为⼆进制型数据传输，对⽅使⽤struct解包 (data_length) #发信息 #注意：执⾏的结果默认jbk编码⽅式,所以客户端必须使⽤gbk⽅式解码 (cmd_res) except Exception: break () () # 关闭服务端套接字if __name__ == '__main__': main()　　

#客户端from socket import *import structdef main(): ip_port=('127.0.0.1',8080) buffer_size=1024 s1 = socket(AF_INET,SOCK_STREAM) t(ip_port) while True: cmd = input('-->') if not cmd:continue if cmd =='quite':break (('utf-8')) length＿data =(4) length = ('i', length＿data)[0] recv_size = 0 # 已经接收到数据的⼤⼩ recv_msg = b'' # 已经接收到的数据 while recv_size < length: r_msg = (buffer_size) recv_msg += r_msg recv_size += len(r_msg) # recv_msg+=(buffer_size) # recv_size=len(recv_msg) print('命令执⾏结果:',recv_('gbk')) ()if __name__=='__main__': main()

总结如果没有粘包的处理服务端把命令执⾏的结果发给客户端的时候，数据太⼤，客户端⼀次没有接收完，在客户端第⼆次执⾏命令的时候，就会把第⼀次没有读取完的部分也读取出来，这属于我们刚才说的第⼆种粘包的情况。有了粘包的处理只要服务端把结果发过来，就算超过⽹卡的限制（拆包发送），客户端能保证在循环的过程中接收完结果