一、黏包成因
tcp协议的拆包机制
当发送端缓冲区的长度大于网卡的MTU时,tcp会将这次发送的数据拆成几个数据包发送出去。
MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。大部分网络设备的MTU都是1500。
如果本机的MTU比网关的MTU大,大的数据包就会被拆开来传送,这样会产生很多数据包碎片,增加丢包率,降低网络速度
面向流的通信特点和Nagle算法
TCP(transport control protocol,传输控制协议)是面向连接的,面向流的,提供高可靠性服务。
收发两端(客户端和服务器端)都要有一一成对的socket,因此,发送端为了将多个发往接收端的包,更有效的发到对方,使用了优化方法(Nagle算法),将多次间隔较小且数据量小的数据,合并成一个大的数据块,然后进行封包。
这样,接收端,就难于分辨出来了,必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
对于空消息:tcp是基于数据流的,于是收发的消息不能为空,这就需要在客户端和服务端都添加空消息的处理机制,防止程序卡住,而udp是基于数据报的,即便是你输入的是空内容(直接回车),也可以被发送,udp协议会帮你封装上消息头发送过去。
可靠黏包的tcp协议:tcp的协议数据不会丢,没有收完包,下次接收,会继续上次继续接收,己端总是在收到ack时才会清除缓冲区内容。数据是可靠的,但是会粘包。
总结:
黏包有两种:
一种是因为发送数据包时,每次发送的包小,因为系统进行优化算法,就将两次的包放在一起发送,减少了资源的重复占用。多次发送会经历多次网络延迟,一起发送会减少网络延迟的次数。因此在发送小数据时会将两次数据一起发送,而客户端接收时,则会一并接收。#即出现多次send会出现黏包
第二种是因为接收数据时,又多次接收,第一次接收的数据量小,导致数据还没接收完,就停下了,剩余的数据会缓存在内存中,然后等到下次接收时和下一波数据一起接收。
二、黏包的解决方案
1,问题的根源在于,接收端不知道发送端将要传送的字节流的长度,所以解决粘包的方法就是围绕,如何让发送端在发送数据前,把自己将要发送的字节流总大小让接收端知晓,然后接收端来一个死循环接收完所有数据。
#_*_coding:utf-8_*_ import socket,subprocess ip_port=('127.0.0.1',8080) s=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=s.accept() print('客户端',addr) while True: msg=conn.recv(1024) if not msg:break res=subprocess.Popen(msg.decode('utf-8'),shell=True,\ stdin=subprocess.PIPE,\ stderr=subprocess.PIPE,\ stdout=subprocess.PIPE) err=res.stderr.read() if err: ret=err else: ret=res.stdout.read() data_length=len(ret) conn.send(str(data_length).encode('utf-8')) data=conn.recv(1024).decode('utf-8') if data == 'recv_ready': conn.sendall(ret) conn.close() 服务端
#_*_coding:utf-8_*_ import socket,time s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(('127.0.0.1',8080)) while True: msg=input('>>: ').strip() if len(msg) == 0:continue if msg == 'quit':break s.send(msg.encode('utf-8')) length=int(s.recv(1024).decode('utf-8')) s.send('recv_ready'.encode('utf-8')) send_size=0 recv_size=0 data=b'' while recv_size < length: data+=s.recv(1024) recv_size+=len(data) print(data.decode('utf-8')) 客户端
2.使用time模块,在每次send的时候加入一个time.sleep(0.01),这种方法可以有效地隔开两次send,断开系统的优化,此种方法虽然可以解决黏包问题,但是会造成发送数据时间长
import socket sk = socket.socket() sk.bind(('127.0.0.1',8090)) sk.listen() conn,addr = sk.accept() ret1 = conn.recv(12) print(ret1) ret2 = conn.recv(12) # ret3 = conn.recv(12) # print(ret2) print(ret3) conn.close() sk.close()
import socket sk = socket.socket() sk.connect(('127.0.0.1',8090)) sk.send(b'hello') import time time.sleep(0.01) sk.send(b'egg') sk.close()
3,先读取文件的大小,然后将文件的大小发送给接收端,这样接收端就可以以文件大小来写入数据。
import json import socket import struct sk =socket.socket()#创建一个socket对象 sk.bind(('127.0.0.1',8080))#绑定本地ip地址与端口 sk.listen()#开启监听 buffer =1024 #设置buffer值大小 conn,addr =sk.accept()#等待客户端连接服务端,得到地址与双共工通道 head_len=conn.recv(4)#接收用struck将数字转长度为4的bytes head_len =struct.unpack('i',head_len)[0]#调用struct模块来解包,得到原来的数字(数字为报头的长度) json_head =conn.recv(head_len).decode('utf-8')#接收json序列化的报头进行解码 head =json.loads(json_head)#将json序列化的报头进行反序列化 filesize =head['filesize']#拿到head字典中键filesize所对应的值 print(filesize)#打印filesize with open(r'dir\%s'%head['filename'],'wb')as f:#dir\文件名,拿到文件的路径,以wb模式打开 while filesize:#当filesize(文件内剩余内容的大小)有值时 if filesize >=buffer:#如果filesize>= buffer值,buffer值是设定的一次接收多少字节的内容 print(filesize) #打印filesize大小 content =conn.recv(buffer)#接收buffer值大小的内容 f.write(content)#写入文件 filesize -=buffer#原来的文件大小减去接收的内容,等于剩余文件的大小 else:#如果文件剩余的内容大小<buffer设定的大小,就全部接收 content =conn.recv(filesize) f.write(content) filesize =0 print('=====>',len(content)) print(filesize) print('服务器端') conn.close() sk.close()
import struct import os import json import socket sk =socket.socket sk.connect(('127.0.0.1',8090)) buffer =1024 head ={'filepath':r'D:\Documents\oCam', 'filename':r'test.mp4', 'filesize':None}#定义一个报头 file_path =os.path.join(head['filepath'],head['filename'])#将文件名与文件路径加载进目录中 filesize = os.path.getsize(file_path)#得到目录中文件的大小 head['filesize'] =filesize#将文件大小赋值回列表中 json_head =json.dumps(head)#将head字典序列化 bytes_head =json_head.encode('utf-8')#将序列化之后的字典进行解码 head_len =len(bytes_head)#计算转码之后字典的长度 pack_len =struct.pack('i',head_len)#调用struct模块将长度转换成长度为4的bytes类型 sk.send(pack_len)#发送pack_len sk.send(bytes_head)#发送bytes_head with open(file_path,'rb')as f: while filesize: print(filesize) if filesize>=buffer: content =f.read(buffer) print('====>',len(content)) sk.send(content) filesize-=buffer else: content =f.read(filesize) sk.send(content) filesize=0 sk.close()
为什么会出现黏包问题?
首先只有在TCP协议中才会出现黏包现象
是因为TCP协议是面向流的协议
在发送的数据传输的过程中海油缓存机制来避免数据丢失
因为在连续发送小数据的时候、以及接收大小不符的时候都容易出现黏包现象
本质还是因为我们在接收数据的时候不知道发送的数据的长短
解决黏包问题
在传输大量数据之前先告诉数据量的大小。
4,使用struct解决黏包
import socket,struct,json import subprocess phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它,在bind前加 phone.bind(('127.0.0.1',8080)) phone.listen(5) while True: conn,addr=phone.accept() while True: cmd=conn.recv(1024) if not cmd:break print('cmd: %s' %cmd) res=subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) err=res.stderr.read() print(err) if err: back_msg=err else: back_msg=res.stdout.read() conn.send(struct.pack('i',len(back_msg))) #先发back_msg的长度 conn.sendall(back_msg) #在发真实的内容 conn.close()
#_*_coding:utf-8_*_ import socket,time,struct s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(('127.0.0.1',8080)) while True: msg=input('>>: ').strip() if len(msg) == 0:continue if msg == 'quit':break s.send(msg.encode('utf-8')) l=s.recv(4) x=struct.unpack('i',l)[0] print(type(x),x) # print(struct.unpack('I',l)) r_s=0 data=b'' while r_s < x: r_d=s.recv(1024) data+=r_d r_s+=len(r_d) # print(data.decode('utf-8')) print(data.decode('gbk')) #windows默认gbk编码