只有TCP有黏包的现象,UDP永远不会黏包
黏包成因
tcp协议的拆包机制
当发送端缓冲区的长度大于网卡的MTU(最大传输率)时&＃xff0c;tcp会将这次发送的数据拆成几个数据包发送出去。
MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。
大部分网络设备的MTU都是1500。如果本机的MTU比网关的MTU大&＃xff0c;大的数据包就会被拆开来传送&＃xff0c;
这样会产生很多数据包碎片&＃xff0c;增加丢包率&＃xff0c;降低网络速度。
面向流的通信特点和Nagle算法
TCP&＃xff08;transport control protocol&＃xff0c;传输控制协议&＃xff09;是面向连接的&＃xff0c;面向流的&＃xff0c;提供高可靠性服务。
收发两端&＃xff08;客户端和服务器端&＃xff09;都要有一一成对的socket&＃xff0c;因此&＃xff0c;发送端为了将多个发往接收端的包&＃xff0c;更有效的发到对方&＃xff0c;使用了优化方法&＃xff08;Nagle算法&＃xff09;&＃xff0c;将多次间隔较小且数据量小的数据&＃xff0c;合并成一个大的数据块&＃xff0c;然后进行封包。
这样&＃xff0c;接收端&＃xff0c;就难于分辨出来了&＃xff0c;必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
对于空消息&＃xff1a;tcp是基于数据流的&＃xff0c;于是收发的消息不能为空&＃xff0c;这就需要在客户端和服务端都添加空消息的处理机制&＃xff0c;防止程序卡住&＃xff0c;而udp是基于数据报的&＃xff0c;即便是你输入的是空内容&＃xff08;直接回车&＃xff09;&＃xff0c;也可以被发送&＃xff0c;udp协议会帮你封装上消息头发送过去。
可靠黏包的tcp协议&＃xff1a;tcp的协议数据不会丢&＃xff0c;没有收完包&＃xff0c;下次接收&＃xff0c;会继续上次继续接收&＃xff0c;己端总是在收到ack时才会清除缓冲区内容。数据是可靠的&＃xff0c;但是会粘包。
成因如下图所示:
发送端可以是一K一K地发送数据&＃xff0c;而接收端的应用程序可以两K两K地提走数据&＃xff0c;当然也有可能一次提走3K或6K数据&＃xff0c;或者一次只提走几个字节的数据。
也就是说&＃xff0c;应用程序所看到的数据是一个整体&＃xff0c;或说是一个流&＃xff08;stream&＃xff09;&＃xff0c;一条消息有多少字节对应用程序是不可见的&＃xff0c;因此TCP协议是面向流的协议&＃xff0c;这也是容易出现粘包问题的原因。
而UDP是面向消息的协议&＃xff0c;每个UDP段都是一条消息&＃xff0c;应用程序必须以消息为单位提取数据&＃xff0c;不能一次提取任意字节的数据&＃xff0c;这一点和TCP是很不同的。
怎样定义消息呢&＃xff1f;可以认为对方一次性write/send的数据为一个消息&＃xff0c;需要明白的是当对方send一条信息的时候&＃xff0c;无论底层怎样分段分片&＃xff0c;TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。
例如基于tcp的套接字客户端往服务端上传文件&＃xff0c;发送时文件内容是按照一段一段的字节流发送的&＃xff0c;在接收方看了&＃xff0c;根本不知道该文件的字节流从何处开始&＃xff0c;在何处结束
此外&＃xff0c;发送方引起的粘包是由TCP协议本身造成的&＃xff0c;TCP为提高传输效率&＃xff0c;发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少&＃xff0c;通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去&＃xff0c;这样接收方就收到了粘包数据。
UDP不会发生黏包
因udp协议是无连接的,面向消息的,提供高效率服务,不会使用块的合并优化算法,由于udp支持的是一对多的模式,所以接收端的skbuff(套接字缓冲区)采用了链式结构来记录每一个到达的UDP包&＃xff0c;在每个UDP包中就有了消息头&＃xff08;消息来源地址&＃xff0c;端口等信息&＃xff09;&＃xff0c;这样&＃xff0c;对于接收端来说&＃xff0c;就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
对于空消息&＃xff1a;tcp是基于数据流的&＃xff0c;于是收发的消息不能为空&＃xff0c;这就需要在客户端和服务端都添加空消息的处理机制&＃xff0c;防止程序卡住&＃xff0c;而udp是基于数据报的&＃xff0c;即便是你输入的是空内容&＃xff08;直接回车&＃xff09;&＃xff0c;也可以被发送&＃xff0c;udp协议会帮你封装上消息头发送过去。
不可靠不黏包的udp协议&＃xff1a;udp的recvfrom是阻塞的&＃xff0c;一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y;x数据就丢失&＃xff0c;这意味着udp根本不会粘包&＃xff0c;但是会丢数据&＃xff0c;不可靠。
udp和tcp一次发送数据的长度限制
用UDP协议发送时&＃xff0c;用sendto函数最大能发送数据的长度为&＃xff1a;65535- IP头(20) – UDP头(8)&＃xff1d;65507字节。用sendto函数发送数据时&＃xff0c;如果发送数据长度大于该值&＃xff0c;则函数会返回错误。&＃xff08;丢弃这个包&＃xff0c;不进行发送&＃xff09; 用TCP协议发送时&＃xff0c;由于TCP是数据流协议&＃xff0c;因此不存在包大小的限制&＃xff08;暂不考虑缓冲区的大小&＃xff09;&＃xff0c;这是指在用send函数时&＃xff0c;数据长度参数不受限制。而实际上&＃xff0c;所指定的这段数据并不一定会一次性发送出去&＃xff0c;如果这段数据比较长&＃xff0c;会被分段发送&＃xff0c;如果比较短&＃xff0c;可能会等待和下一次数据一起发送。
黏包发生的情况
一. 发送方的缓存机制
发送端需要等缓冲区满才发送出去,造成黏包(发送数据时间间隔很短,数据有不大,会合到一起,产生黏包)
import socketip_port&＃61;(&＃39;127.0.0.1&＃39;,8080)tcp_socket_server&＃61;socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)conn,addr&＃61;tcp_socket_server.accept()data1&＃61;conn.recv(10)
data2&＃61;conn.recv(10)print(&＃39;----->&＃39;,data1.decode(&＃39;utf-8&＃39;))
print(&＃39;----->&＃39;,data2.decode(&＃39;utf-8&＃39;))conn.close()
import socket
BUFSIZE&＃61;1024
ip_port&＃61;(&＃39;127.0.0.1&＃39;,8080)s&＃61;socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res&＃61;s.connect_ex(ip_port)s.send(&＃39;hello&＃39;.encode(&＃39;utf-8&＃39;))
s.send(&＃39;egg&＃39;.encode(&＃39;utf-8&＃39;))
二. 接收方的缓存机制
接收方不及时接受缓冲区的包,造成多个包接受(客户端发送了一段数据,服务端只收了一小部分,服务端下次再去收数据的时候还是从缓冲区拿上次遗留的数据,产生黏包)
import socketip_port&＃61;(&＃39;127.0.0.1&＃39;,8080)tcp_socket_server&＃61;socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)conn,addr&＃61;tcp_socket_server.accept()data1&＃61;conn.recv(2) #一次没有收完整
data2&＃61;conn.recv(10)#下次收的时候,会先取旧的数据,然后取新的print(&＃39;----->&＃39;,data1.decode(&＃39;utf-8&＃39;))
print(&＃39;----->&＃39;,data2.decode(&＃39;utf-8&＃39;))conn.close()
import socket
BUFSIZE&＃61;1024
ip_port&＃61;(&＃39;127.0.0.1&＃39;,8080)s&＃61;socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res&＃61;s.connect_ex(ip_port)s.send(&＃39;hello egg&＃39;.encode(&＃39;utf-8&＃39;))
小结:
黏包只发生在tcp协议中:
- 表面上看,黏包问题是因为发送方和接收方的缓存机制,tcp协议面向流通信的特点造成的
- 本质上,主要还是因为接收方不知道消息之间的界限,不知道一次性提取多少字节的数据所造成的
黏包的解决方案
提高接收端的知情权,让发送端在发送数据前,把自己将要发送的字节流总大小让接收端知晓,然后接收端来一个死循环接受完所有的数据
import socket,subprocess
ip_port&＃61;(&＃39;127.0.0.1&＃39;,8080)
s&＃61;socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)s.bind(ip_port)
s.listen(5)while True:conn,addr&＃61;s.accept()print(&＃39;客户端&＃39;,addr)while True:msg&＃61;conn.recv(1024)if not msg:breakres&＃61;subprocess.Popen(msg.decode(&＃39;utf-8&＃39;),shell&＃61;True,\stdin&＃61;subprocess.PIPE,\stderr&＃61;subprocess.PIPE,\stdout&＃61;subprocess.PIPE)err&＃61;res.stderr.read()if err:ret&＃61;errelse:ret&＃61;res.stdout.read()data_length&＃61;len(ret)conn.send(str(data_length).encode(&＃39;utf-8&＃39;))data&＃61;conn.recv(1024).decode(&＃39;utf-8&＃39;)if data &＃61;&＃61; &＃39;recv_ready&＃39;:conn.sendall(ret)conn.close()
import socket
s&＃61;socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res&＃61;s.connect_ex((&＃39;127.0.0.1&＃39;,8080))while True:msg&＃61;input(&＃39;>>: &＃39;).strip()if len(msg) &＃61;&＃61; 0: continueif msg &＃61;&＃61; &＃39;quit&＃39;:breaks.send(msg.encode(&＃39;utf-8&＃39;))length&＃61;int(s.recv(1024).decode(&＃39;utf-8&＃39;))s.send(&＃39;recv_ready&＃39;.encode(&＃39;utf-8&＃39;))send_size&＃61;0recv_size&＃61;0data&＃61;b&＃39;&＃39;while recv_size < length:data &＃43;&＃61; s.recv(1024)recv_size &＃43;&＃61; len(data)print(data.decode(&＃39;utf-8&＃39;))
存在的问题&＃xff1a;
程序的运行速度远快于网络传输速度&＃xff0c;所以在发送一段字节前&＃xff0c;先用send去发送该字节流长度&＃xff0c;这种方式会放大网络延迟带来的性能损耗
方案进阶
借助struck模块,该模块可以把要发送的数据长度转换成固定长度的字节,这样客户端每次接受消息之前只要先接受这个固定长度字节的内容看一看接下来要接受的消息大小,那么最终接受的数据只要达到这个值就停止&＃xff0c;就能刚好不多不少的接收完整的数据了。
struck模块
可以把一个类型,如数字,字符串转换成固定长度的bytes
>>> struct.pack(&＃39;i&＃39;,1111111111111)struct.error: &＃39;i&＃39; format requires -2147483648 <&＃61; number <&＃61; 2147483647 #这个是范围
import json,struct
#假设通过客户端上传1T:1073741824000的文件a.txt#为避免粘包,必须自定制报头
header&＃61;{&＃39;file_size&＃39;:1073741824000,&＃39;file_name&＃39;:&＃39;/a/b/c/d/e/a.txt&＃39;,&＃39;md5&＃39;:&＃39;8f6fbf8347faa4924a76856701edb0f3&＃39;} #1T数据,文件路径和md5值#为了该报头能传送,需要序列化并且转为bytes
head_bytes&＃61;bytes(json.dumps(header),encoding&＃61;&＃39;utf-8&＃39;) #序列化并转成bytes,用于传输#为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节
head_len_bytes&＃61;struct.pack(&＃39;i&＃39;,len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度#客户端开始发送
conn.send(head_len_bytes) #先发报头的长度,4个bytes
conn.send(head_bytes) #再发报头的字节格式
conn.sendall(文件内容) #然后发真实内容的字节格式#服务端开始接收
head_len_bytes&＃61;s.recv(4) #先收报头4个bytes,得到报头长度的字节格式
x&＃61;struct.unpack(&＃39;i&＃39;,head_len_bytes)[0] #提取报头的长度
head_bytes&＃61;s.recv(x) #按照报头长度x,收取报头的bytes格式
header&＃61;json.loads(json.dumps(header)) #提取报头#最后根据报头的内容提取真实的数据,比如
real_data_len&＃61;s.recv(header[&＃39;file_size&＃39;])
s.recv(real_data_len)
使用详解
| 发送时 | 接收时 |
| 先发送struct转换好的数据长度4字节 | 先接受4个字节使用struct转换成数字来获取要接收的数据长度 |
| 再发送数据 | 再按照长度接收数据 |
import socket,struct,json
import subprocess
phone&＃61;socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它&＃xff0c;在bind前加
phone.bind((&＃39;127.0.0.1&＃39;,8080))phone.listen(5)while True:conn,addr&＃61;phone.accept()while True:cmd&＃61;conn.recv(1024)if not cmd:breakprint(&＃39;cmd: %s&＃39; %cmd)res&＃61;subprocess.Popen(cmd.decode(&＃39;utf-8&＃39;),shell&＃61;True,stdout&＃61;subprocess.PIPE,stderr&＃61;subprocess.PIPE)err&＃61;res.stderr.read()print(err)if err:back_msg&＃61;errelse:back_msg&＃61;res.stdout.read()conn.send(struct.pack(&＃39;i&＃39;,len(back_msg))) #先发back_msg的长度conn.sendall(back_msg) #在发真实的内容
conn.close()
import socket,time,structs&＃61;socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res&＃61;s.connect_ex((&＃39;127.0.0.1&＃39;,8080))while True:msg&＃61;input(&＃39;>>: &＃39;).strip()if len(msg) &＃61;&＃61; 0:continueif msg &＃61;&＃61; &＃39;quit&＃39;:breaks.send(msg.encode(&＃39;utf-8&＃39;))l&＃61;s.recv(4)x&＃61;struct.unpack(&＃39;i&＃39;,l)[0]print(type(x),x)# print(struct.unpack(&＃39;I&＃39;,l))r_s&＃61;0data&＃61;b&＃39;&＃39;while r_s < x:r_d&＃61;s.recv(1024)data&＃43;&＃61;r_dr_s&＃43;&＃61;len(r_d)# print(data.decode(&＃39;utf-8&＃39;))print(data.decode(&＃39;gbk&＃39;)) #windows默认gbk编码
我们还可以把报头做成字典&＃xff0c;字典里包含将要发送的真实数据的详细信息&＃xff0c;然后json序列化&＃xff0c;然后用struck将序列化后的数据长度打包成4个字节&＃xff08;4个足够用了&＃xff09;
发送时:
- 先发报头长度
- 再编码报头内容然后发送
- 最后发真实内容
接收时:
- 先收报头长度&＃xff0c;用struct取出来
- 根据取出的长度收取报头内容&＃xff0c;然后解码&＃xff0c;反序列化
- 从反序列化的结果中取出待取数据的详细信息&＃xff0c;然后去取真实的数据内容
import socket,struct,json
import subprocess
phone&＃61;socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它&＃xff0c;在bind前加
phone.bind((&＃39;127.0.0.1&＃39;,8080))phone.listen(5)while True:conn,addr&＃61;phone.accept()while True:cmd&＃61;conn.recv(1024)if not cmd:breakprint(&＃39;cmd: %s&＃39; %cmd)res&＃61;subprocess.Popen(cmd.decode(&＃39;utf-8&＃39;),shell&＃61;True,stdout&＃61;subprocess.PIPE,stderr&＃61;subprocess.PIPE)err&＃61;res.stderr.read()print(err)if err:back_msg&＃61;errelse:back_msg&＃61;res.stdout.read()headers&＃61;{&＃39;data_size&＃39;:len(back_msg)}head_json&＃61;json.dumps(headers)head_json_bytes&＃61;bytes(head_json,encoding&＃61;&＃39;utf-8&＃39;)conn.send(struct.pack(&＃39;i&＃39;,len(head_json_bytes))) #先发报头的长度conn.send(head_json_bytes) #再发报头conn.sendall(back_msg) #在发真实的内容
conn.close()
from socket import *
import struct,jsonip_port&＃61;(&＃39;127.0.0.1&＃39;,8080)
client&＃61;socket(AF_INET,SOCK_STREAM)
client.connect(ip_port)while True:cmd&＃61;input(&＃39;>>: &＃39;)if not cmd:continueclient.send(bytes(cmd,encoding&＃61;&＃39;utf-8&＃39;))head&＃61;client.recv(4)head_json_len&＃61;struct.unpack(&＃39;i&＃39;,head)[0]head_json&＃61;json.loads(client.recv(head_json_len).decode(&＃39;utf-8&＃39;))data_len&＃61;head_json[&＃39;data_size&＃39;]recv_size&＃61;0recv_data&＃61;b&＃39;&＃39;while recv_size < data_len:recv_data&＃43;&＃61;client.recv(1024)recv_size&＃43;&＃61;len(recv_data)print(recv_data.decode(&＃39;utf-8&＃39;))#print(recv_data.decode(&＃39;gbk&＃39;)) #windows默认gbk编码
京公网安备 11010802041100号