标签：href tle 不能 head 高效 因此 bre NPU 上传
粘包问题是所有语言中都会有的问题，因为只要使用了TCP协议，即使是通过socket编程也都会产生的问题。
注意：只有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段后一次发送出去，这样接收方就收到了粘包数据。
udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠
TCP的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。
假设客户端分别发送了两个数据包D1和D2给服务端，由于服务端一次读取到的字节数是不确定的，故可能存在以下4种情况。
特例：如果此时服务端TCP接收滑窗非常小，而数据包D1和D2比较大，很有可能会发生第五种可能，即服务端分多次才能将D1和D2包接收完全，期间发生多次拆包。
使用方法：
import struct
#把一个数字打包成固定长度的4字节，得到字节格式数据
obj=struct.pack('i',1024) # 'i'是格式
print(obj)
print(len(obj))
# 解包，得到元祖类型数据
l=struct.unpack('i',obj)[0]
print(l)问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。
服务器：
import socket
import subprocess
import struct
HOST = "192.168.11.237"
PORT = 8082
soc = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
soc.bind((HOST,PORT))
soc.listen(5)
while 1:
print("等待连接。。。")
conn,addr = soc.accept()
print("连接成功。。。\n")
while 1:
try:
data = conn.recv(1024)
if len(data)==0: # 长度0说明断开了连接。在windows中没用，在linux中才有用
break
# 把执行正确的内容放到管道中
obj = subprocess.Popen(str(data, encoding="utf8"), shell=True, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
# 执行的结果 b 格式,gbk编码(windows平台)
suc_data = obj.stdout.read()
fail_data = obj.stderr.read()
if suc_data:
# 1.先打包数据长度，为四个字节，在发过去
head = struct.pack("i", len(suc_data))
conn.send(head) # 作为头信息发过去，字节格式
# 2.发真正的数据信息
conn.send(suc_data)
else:
# 1.先打包数据长度，为四个字节，在发过去
head = struct.pack("i", len(fail_data))
conn.send(head) # 作为头信息发过去，字节格式
# 发错误信息
conn.send(fail_data)
except:
print("客户机连接中断。。。")
break
conn.close()
soc.close()客户端：
import socket
import struct
HOST = "192.168.11.237"
PORT = 8082
soc = socket.socket()
soc.connect((HOST,PORT))
while 1:
try:
cmd = input("请输入需要执行的命令")
soc.send(cmd.encode("utf8"))
# 1.得到数据的头信息并解包
head = soc.recv(4)
data_len = struct.unpack("i",head)[0]
if head == 0:
break
# 2.根据头信息，拿到数据长度来接收数据
str_data = b""
while data_len:
if data_len > 1024:
data = soc.recv(1024) # 你要接收的数据长度必须等于真实接收到的数据长度才可以停止
str_data += data
data_len -= len(data)
else:
data = soc.recv(data_len)
str_data += data
data_len -= len(data)
print(str_data.decode("gbk"))
except Exception as a:
print("服务器关闭了:", a)
break
# 4.关闭连接
soc.close()简单版解决方案确实能解决粘包问题，但是如果当要传输的数据太大则就会发生问题。下面给出我的解决方案
服务器：
import socket
import subprocess
import struct
import json
HOST = "192.168.11.24"
PORT = 8080
soc = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
soc.bind((HOST,PORT))
soc.listen(5)
while 1:
print("等待连接。。。")
conn,addr = soc.accept()
print(f"主机{addr}连接成功,准备接收消息中。。。")
while 1:
try:
# 接收命令
cmd = conn.recv(1024)
# 处理命令
obj = subprocess.Popen(cmd.decode("utf8"), shell=True, stdout=subprocess.PIPE,stderr=subprocess.PIPE)
suc_data = obj.stdout.read()
fail_data = obj.stderr.read()
if suc_data:
# 1.先构造一个字典，把头信息放到字典中
head_dic = {"data_size": len(suc_data), "md5":None, "file_name": None}
# 2.对该字典序列化，得到字符串(json串)
head_dic_json_byte = (json.dumps(head_dic)).encode("utf8")
# 3.将 序列化后的字典 长度打包,作为头部
head = struct.pack("i",len(head_dic_json_byte))
# 4.先发头部
conn.send(head)
# 5.再发 序列化后的字典(字节类型)
conn.send(head_dic_json_byte)
# 6.最后再发真正的数据
conn.send(suc_data)
else:
# 1.先构造一个字典，把头信息放到字典中
head_dic = {"data_size": len(fail_data), "md5": None, "file_name": None}
# 2.对该字典序列化，得到字符串(json串)
head_dic_json_byte = (json.dumps(head_dic)).encode("utf8")
# 3.将 序列化后的字典 长度打包,作为头部(字节类型)
head = struct.pack("i", len(head_dic_json_byte))
# 4.先发头部
conn.send(head)
# 5.再发 序列化后的字典(字节类型)
conn.send(head_dic_json_byte)
# 6.最后再发真正的数据
conn.send(fail_data)
except:
print("客户机连接中断。。。\n")
break
conn.close()
soc.close()客户端
import socket
import struct
import json
HOST = "192.168.11.24"
PORT = 8080
soc = socket.socket()
soc.connect((HOST,PORT))
while 1:
try:
cmd = input("请输入需要执行的命令")
soc.send(cmd.encode("utf8"))
# 1.先拿到头数据，并解包
head = soc.recv(4)
head_dic_len = struct.unpack("i",head)[0]
if len(head) == 0: # 服务器关闭了
break
# 2.根据头字典长度拿到头字典信息,进行反序列化，拿到头字典
head_dic_btye = soc.recv(head_dic_len)
head_dic = json.loads(head_dic_btye) # json可以直接反序列化bytes类型
# 3.根据头字典中的数据长度拿到真正的数据
data_len= head_dic.get("data_size")
str_data = b""
while data_len:
if data_len > 1024:
data = soc.recv(1024) # 你要接收的数据长度必须等于真实接收到的数据长度才可以停止
str_data += data
data_len -= len(data)
else:
data = soc.recv(data_len)
str_data += data
data_len -= len(data)
print(str_data.decode("gbk"))
except Exception as a:
print("服务器关闭了:", a)
break
# 4.关闭连接
soc.close()标签：href tle 不能 head 高效 因此 bre NPU 上传
原文地址：https://www.cnblogs.com/xichenHome/p/11508243.html
