一、黏包成因
1、tcp協議的拆包機制
當發送端緩沖區的長度大於網卡的MTU時，tcp會將這次發送的數據拆成幾個數據包發送出去。 
MTU是Maximum Transmission Unit的縮寫。意思是網絡上傳送的最大數據包。MTU的單位是字節。 
大部分網絡設備的MTU都是1500。如果本機的MTU比網關的MTU大，大的數據包就會被拆開來傳送，
這樣會產生很多數據包碎片，增加丟包率，降低網絡速度。


2、tcp的合包機制
TCP（transport control protocol，傳輸控制協議）是面向連接的，面向流的，提供高可靠性服務。
收發兩端（客戶端和服務器端）都要有一一成對的socket，因此，發送端為了將多個發往接收端的包，更有效的發到對方，
使用了優化方法（Nagle算法），將多次間隔較小且數據量小的數據，合並成一個大的數據塊，然後進行封包。
但是這樣，接收端，就難於分辨出來了，必須提供科學的拆包機制。 即面向流的通信是無消息保護邊界的。 
對於空消息：tcp是基於數據流的，於是收發的消息不能為空，這就需要在客戶端和服務端都添加空消息的處理機制，防止程序卡住，
而udp是基於數據報的，即便是你輸入的是空內容（直接回車），也可以被發送，udp協議會幫你封裝上消息頭發送過去。 
可靠黏包的tcp協議：tcp的協議數據不會丟，沒有收完包，下次接收，會繼續上次繼續接收，己端總是在收到ack時才會清除緩沖區內容。數據是可靠的，但是會粘包。


 
3、說明
發送端可以是一K一K地發送數據，而接收端的應用程序可以兩K兩K地提走數據，當然也有可能一次提走3K或6K數據，或者一次只提走幾個字節的數據。
也就是說，應用程序所看到的數據是一個整體，或說是一個流（stream），一條消息有多少字節對應用程序是不可見的，因此TCP協議是面向流的協議，這也是容易出現粘包問題的原因。
而UDP是面向消息的協議，每個UDP段都是一條消息，應用程序必須以消息為單位提取數據，不能一次提取任意字節的數據，這一點和TCP是很不同的。
怎樣定義消息呢？可以認為對方一次性write/send的數據為一個消息，需要明白的是當對方send一條信息的時候，無論底層怎樣分段分片，TCP協議層會把構成整條消息的數據段排序完成後才呈現在內核緩沖區。


也就是：
用UDP協議發送時，用sendto函數最大能發送數據的長度為：
 
65535- IP頭(20) – UDP頭(8)＝65507字節。用sendto函數發送數據時，如果發送數據長度大於該值，
則函數會返回錯誤。（丟棄這個包，不進行發送） 

用TCP協議發送時，由於TCP是數據流協議，因此不存在包大小的限制（暫不考慮緩沖區的大小），這是指在用send函數時，數據長度參數不受限制。
而實際上，所指定的這段數據並不一定會一次性發送出去，如果這段數據比較長，會被分段發送，如果比較短，可能會等待和下一次數據一起發送。




例如：
基於tcp的套接字客戶端往服務端上傳文件，發送時文件內容是按照一段一段的字節流發送的，在接收方看了，根本不知道該文件的字節流從何處開始，在何處結束
此外，發送方引起的粘包是由TCP協議本身造成的，TCP為提高傳輸效率，發送方往往要收集到足夠多的數據後才發送一個TCP段。若連續幾次需要send的數據都很少，
通常TCP會根據優化算法把這些數據合成一個TCP段後一次發送出去，這樣接收方就收到了粘包數據。



上代碼：
服務端：
 
import socket
sk = socket.socket()
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
sk.bind((‘127.0.0.1‘,8000))
sk.listen()

conn,addr = sk.accept()
ret = conn.recv(1024)
print(ret.decode(‘utf-8‘))
conn.close()
sk.close()


客戶端：
import socket
sk = socket.socket()
sk.connect((‘127.0.0.1‘,8000))
sk.send(b‘hello,‘)
sk.send(b‘world,‘)
sk.send(b‘hi‘)
sk.close()


結果：
hello,world,hi

解釋：
正常來說，一個send必須對應一個recv，
但是我們都知道python程序是由上至下執行的，那麽：
sk.send(b‘hello,‘)
sk.send(b‘world,‘)
sk.send(b‘hi‘)
上面這三句代碼幾乎在一瞬間就執行了，而由於要發送的數據很小，而且是時間間隔很短，
發送方就會把這幾條數據合成一條數據，再發送過去，在接收端其實收到的就是一次傳來的數據，
所以這個時候三次send，對應一次recv，這就是黏包。


4、總結
黏包現象只發生在tcp協議中：
1.從表面上看，黏包問題主要是因為發送方和接收方的緩存機制、tcp協議面向流通信的特點。
2.實際上，主要還是因為接收方不知道消息之間的界限，不知道一次性提取多少字節的數據所造成的


合包現象
    數據很短
    時間間隔短
拆包現象
    大數據會發生拆分
    不會一次性的全部發送到對方
    對方在接受的時候很可能沒有辦法一次性接收到所有的信息
    那麽沒有接受完的信息很可能和後面的信息黏在一起
粘包現象只發生在tcp協議
    tcp協議的傳輸 是 流式傳輸
    每一條信息與信息之間是沒有邊界的

udp協議中是不會發生粘包現象的
    適合短數據的發送
    不建議你發送過長的數據
    數據過長會增大你數據丟失的幾率

在程序中會出現粘包：收發數據的邊界不清晰
接收數據這一端不知道要接收數據的長度到底是多少





二、黏包解決方案
1、解決方案一
問題的根源在於，接收端不知道發送端將要傳送的字節流的長度，所以解決粘包的方法就是圍繞，如何讓發送端在發送數據前，
把自己將要發送的字節流總大小讓接收端知曉，然後接收端來一個死循環接收完所有數據。

就是說：
如果你要發送一個數據----hello，它是5個字節的，
你在接收端設置了只接收5個字節，那麽就算發生黏包也沒關系，
因為你只接收了5個字節，黏在一起的剩下的數據也就沒有讀取到了。
send(b‘hello‘)   ----->   recv(5)

那麽我們就有了一個思路，就是在發送消息的時候，我們主動告訴接收端我們要發送的數據的長度，
接收端按照接收的長度來接收數據。例如：
發送端：
send(b‘5hello‘)  


接收端：
num = recv(1)  # 代表接收第一個字節，也就是只把長度5接收了
num_len = int(num.decode(‘utf-8‘))  # 把長度的類型轉成整型
msg = recv(num_len)  # 按照長度接收數據


代碼：
服務端：
import socket
sk = socket.socket()
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
sk.bind((‘127.0.0.1‘,8001))
sk.listen()

conn,addr = sk.accept()
conn.send(b‘5hello‘)
conn.send(b‘2hi‘)

conn.close()
sk.close()


客戶端：
import socket
sk = socket.socket()
sk.connect((‘127.0.0.1‘,8001))

num = sk.recv(1)
num_len = int(num.decode(‘utf-8‘))
msg1 = sk.recv(num_len)
print(msg1)

num2 = sk.recv(1)
num2_len = int(num2.decode(‘utf-8‘))
msg2 = sk.recv(num2_len)
print(msg2)

sk.close()

結果：
hello
hi

但是這樣寫每次只能接收個位數的數據，我們可以把長度設置成4個長度，即0000-9999
發送端：
send(b‘0005hello‘)  


接收端：
num = recv(4)  # 代表接收前四個字節，也就是只把長度0005接收了
num_len = int(num.decode(‘utf-8‘))  # 把長度的類型轉成整型
msg = recv(num_len)  # 按照長度接收數據


但實際中，我們要傳的數據往往很大的而這種方式雖然能解決一些問題，但是這樣寫一次也最多發送9999個字節(大概9.7KB)，
那麽如果2G的東西就要發送大概21萬次循環才能發送完。


補充一個字符串的方法zfill：在左邊給字符補0
print(‘1‘.zfill(4))   # 0001



2、解決方案2
首先介紹一個模塊struct：該模塊可以把一個類型，如數字，轉成固定長度(4)的bytes
import struct
ret1 = struct.pack(‘i‘,10238976)    # i代表把整型的數據轉換成bytes類型的數據
ret2 = struct.pack(‘i‘,1)

print(ret1,len(ret1))  # b‘\x00<\x9c\x00‘  4
print(ret2,len(ret2))  # b‘\x01\x00\x00\x00‘ 4
可以看到：數字10238976轉成bytes後，長度為4，數字1轉成bytes後，長度也是為4。

num1 = struct.unpack(‘i‘,ret1)   # unpack把bytes類型轉成第一個參數代表的類型(這裏是i，也就是int 整型，但返回的是一個元組)
print(num1)  # (10238976,)  元組
print(num1[0])  # 10238976 取元組的第一個值即可

註意:‘i‘ 所能轉換的數字範圍是 -2147483648 <= number <= 2147483647 
超出這個範圍就會報錯，就是不能這樣寫  struct.pack(‘i‘,2147483648)



代碼：
服務端：
import socket
import struct
sk = socket.socket()
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
sk.bind((‘127.0.0.1‘,8002))
sk.listen()

conn,addr = sk.accept()
while True:
    msg = input(‘>>>:‘).encode(‘utf-8‘)  # 要發送的內容
    pack_num = struct.pack(‘i‘,len(msg))  # 計算內容的長度
    conn.send(pack_num)  
    conn.send(msg)
conn.close()
sk.close()




客戶端：
import socket
import struct

sk = socket.socket()
sk.connect((‘127.0.0.1‘,8002))

while True:
    pack_num = sk.recv(4)
    num = struct.unpack(‘i‘,pack_num)[0]
    ret = sk.recv(num)
    print(ret.decode(‘utf-8‘))
sk.close()

socket之黏包