socket之黏包

複製代碼
1、黏包成因
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協議中是不會發生粘包現象的
    適合短數據的發送
    不建議你發送過長的數據
    數據過長會增大你數據丟失的概率

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





2、黏包解決方案
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()
複製代碼
相關文章
相關標籤/搜索