黏包

黏包只看表面字的意思就是 黏在一起  ：

 

一、TCP黏包问题
TCP黏包问题是因为发送方把若干数据发送，接收方收到数据时候黏在一包，从接受缓冲区来看，后一包的数据黏在前一包的尾部。

二、黏包出现的原因

TCP黏包问题主要出现在两个方面
（1）发送方问题
首先TCP会默认使用Nagle算法，Nagle算法主要做两件事。
第一：上一包分组得到确认，才会发送下一分组。
第二：收集多个小组，在一个确认到来时一起发送。
由此可见Nagle算法会使得数据在发送方造成黏包问题 。
（2）接收方问题
TCP接收方接收到分组的时候，并不会立刻提交到应用层处理，收到的数据放在接收缓存里面，然后应用程序会主动从接受缓存里读取接收的分组，这样以来，如果TCP接收分组的速度大于应用读取分组的速度，多个包的数据会存至缓存区里面，应用读取数据就可能会产生黏包问题。
！

 

粘包的原因

3-1 直接原因

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

3-2  根本原因

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

3-3 总结

1.  TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
2. UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。  即面向消息的通信是有消息保护边界的。
3. tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，实验略

 

UDP是不会发生黏包的

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时才会清除缓冲区内容。数据是可靠的，但是会粘包。

 

 基于tcp协议特点的黏包现象成因 

 

 就是基于TCP协议，你的发送端的信息在内核状态然后会把信息都集中在一起然后集合在一起 发送过去就是黏包了。然后你的接收端会把你发送的信息在接收端进行

 你设置发送的信息是1024个字节 但是呢 你根本没有发送这么多的字节 所以你的网络就会等待你发送的两句话都黏在一起然后把信息接受完 黏合一起发送过去 你的接收端就会收到的是黏合后的信息

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

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

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

 我们为了解决黏包可以先把你要传递的信息给放在容器内 你要传送的 容器内存放你的要发送的内容的名字和字节的大小，然后根据struct模块来制定一个规则 这个规则是用来进行你的内容的限制的，比如我要把我的内容以int类型的形式传递过去 先传送几个字节 然后再把你的容器的内容传过去 告诉对面你传递内容的名字和大小，等对面进行接受的时候只接受这个文件名并且只接受这么多的内容，接受完就停止不再接收了 就解决了黏包的问题

 

 

我们以发送一个文件为例子来进行一个解包的过程：

 

server端口：
import os
import json
import struct
import socket
sk = socket.socket()
sk.bind(('127.0.0.4',9097))
sk.listen()
conn,addr = sk.accept()
dic = {'filename':'文件名',
       'filesize':os.path.getsize(r'文件路径')
       }
str_dic = json.dumps(dic).decode('UTF-8')  # 你的容器字典在网络中传输需要进行序列化
dic_len = struct.pack('i',len(str_dic)) # struct模块中的 pack是吧你的信息转化为所对应的类型的
conn.send(dic_len) # 把你存放信息的容器的开头的所对应的类型的元素给传递过去
conn.send(str_dic) # 再把这个容器整体给传送过去
with open(r'文件路径','rb')as f: # 以rb的形式读取整个文件
    content = f.read()
conn.send(content) # 把你读取的所有的信息给传递过去
conn.close()
sk.close()



client端：

import socket
import json
import struct
sk = socket.socket()
sk.connect(('127.0.0.0.4',9080))
dic_len = sk.recv(4) # 因为你的server规定的是先发送包的4个字节 这边就先接收4个字节
dic_len = struct.unpack('i',dic_len)[0]  # 把你接收过来的信息进行解包
print(dic_len)
# 因为上面的因为已经对好暗号了 所以可以执行下面的
str_dic = sk.recv(dic_len) .decode('UTF-8')  # 接收及收过来的信息并且进行转码  这个是发送的容器的大小
dic = json.loads(str_dic) # 接收过来的信息是序列化后的信息我们需要进行反序列号
with open(dic['filename'], 'wb')as f:
    content = sk.recv(dic['filesize'])
    f.write(content)
sk.close()

上面的具体版本：

server端口：

import os
import json
import struct
import socket
sk = socket.socket()
sk.bind(('192.168.11.92',9000))
sk.listen()

conn,addr = sk.accept()
print(addr)
dic = {'filename':'1.复习.py',
       'filesize':os.path.getsize(r'D:\python11\day35\1.复习.py')}
str_dic = json.dumps(dic).encode('utf-8')
dic_len = struct.pack('i',len(str_dic))
conn.send(dic_len)
conn.send(str_dic)
with open(r'D:\python11\day35\1.复习.py','rb') as f:
    content = f.read()
conn.send(content)
conn.close()
sk.close()








client 端口:


import json
import struct
import socket

sk = socket.socket()
sk.connect(('192.168.11.92',9000))

dic_len = sk.recv(4)
dic_len = struct.unpack('i',dic_len)[0]
str_dic = sk.recv(dic_len).decode('utf-8')
dic = json.loads(str_dic)

with open(dic['filename'],'wb') as f:
    content = sk.recv(dic['filesize'])
    f.write(content)
sk.close()

 

 解决黏包就是你先规定好然后运用struct模块进行的规定好 然后再进行的匹配这个规定然后进行你的信心的传递的约束的匹配就可以解决黏包了

 

 

发送一个文件的或者视频的解决黏包过程;

因为TCP传输太稳定不让丢失包 所以必须会等待所有的 包一起完成才会传输 所以就造成了黏包 ，使用struct进行解包

传输文件：

server：

import os
import json
import struct
import socket

# D:\python11\day35\1.复习.py
sk = socket.socket()
sk.bind(('192.168.11.92',9000))
sk.listen()

conn,addr = sk.accept()
print(addr)
dic = {'filename':'1.复习.py',
       'filesize':os.path.getsize(r'D:\python11\day35\1.复习.py')}
str_dic = json.dumps(dic).encode('utf-8')
dic_len = struct.pack('i',len(str_dic))
conn.send(dic_len)
conn.send(str_dic)
with open(r'D:\python11\day35\1.复习.py','rb') as f:
    content = f.read()
conn.send(content)
conn.close()
sk.close()


client：
import json
import struct
import socket

sk = socket.socket()
sk.connect(('192.168.11.92',9000))

dic_len = sk.recv(4)
dic_len = struct.unpack('i',dic_len)[0]
str_dic = sk.recv(dic_len).decode('utf-8')
dic = json.loads(str_dic)

with open(dic['filename'],'wb') as f:
    content = sk.recv(dic['filesize'])
    f.write(content)
sk.close()

 

传输视频或者文件

server:


import os
import json
import socket
import struct
filepath = r'D:\python11期视频笔记\python11期day35\视频.zip'

sk = socket.socket()
sk.bind(('127.0.0.1',9000))
sk.listen()

conn,addr = sk.accept()
filename = os.path.basename(filepath)
filesize = os.path.getsize(filepath)
dic = {'filename':filename,'filesize':filesize}
str_dic = json.dumps(dic).encode('utf-8')
len_dic = len(str_dic)
length = struct.pack('i',len_dic)
conn.send(length)   # dic的长度
conn.send(str_dic)  # dic
with open(filepath,'rb') as f:  # 文件
    while filesize:
        content = f.read(4096)
        conn.send(content)
        filesize -= len(content)
conn.close()
sk.close()




client:


import json
import struct
import socket

sk = socket.socket()
sk.connect(('127.0.0.1',9000))

dic_len = sk.recv(4)
dic_len = struct.unpack('i',dic_len)[0]
dic = sk.recv(dic_len)
str_dic = dic.decode('utf-8')
dic = json.loads(str_dic)
with open(dic['filename'],'wb') as f:
    while dic['filesize']:
        content = sk.recv(4096)
        dic['filesize'] -= len(content)
        f.write(content)
sk.close()

 

 

 

 

server:


import os
import json
import socket
import struct
filepath = r'D:\python11期视频笔记\python11期day35\视频.zip'

sk = socket.socket()
sk.bind(('127.0.0.1',9000))
sk.listen()

conn,addr = sk.accept()
filename = os.path.basename(filepath)
filesize = os.path.getsize(filepath)
dic = {'filename':filename,'filesize':filesize}
str_dic = json.dumps(dic).encode('utf-8')
len_dic = len(str_dic)
length = struct.pack('i',len_dic)
conn.send(length)   # dic的长度
conn.send(str_dic)  # dic
with open(filepath,'rb') as f:  # 文件
    while filesize:
        content = f.read(4096)
        conn.send(content)
        filesize -= len(content)
conn.close()
sk.close()




client:


import json
import struct
import socket

sk = socket.socket()
sk.connect(('127.0.0.1',9000))

dic_len = sk.recv(4)
dic_len = struct.unpack('i',dic_len)[0]
dic = sk.recv(dic_len)
str_dic = dic.decode('utf-8')
dic = json.loads(str_dic)
with open(dic['filename'],'wb') as f:
    while dic['filesize']:
        content = sk.recv(4096)
        dic['filesize'] -= len(content)
        f.write(content)
sk.close()