一、數據緩沖區

緩沖區(buffer)，它是內存空間的一部分。也就是說，在內存空間中預留了一定的存儲空間，這些存儲空間用來緩沖輸入或輸出的數據，這部分預留的空間就叫做緩沖區，顯然緩沖區是具有一定大小的。

二、為什么要緩沖區 (詳情參考：https://www.cnblogs.com/mlgjb/p/7991903.html)

1.可以解除高速設備與低速設備的不匹配，高速設備需要等待低速設備的制約關系，數據可以直接送往緩沖區，高速設備不用再等待低速設備，提高了計算機的效率。

2.可以減少數據的讀寫次數，如果每次數據只傳輸一點數據，就需要傳送很多次，這樣會浪費很多時間，因為開始讀寫與終止讀寫所需要的時間很長，如果將數據送往緩沖區，待緩沖區滿后再進行傳送會大大減少讀寫次數，這樣就可以節省很多時間。

三、粘包現象

1、小數據傳輸粘包

源代碼:

importsocket

server=socket.socket()

server.bind(('127.0.0.1',8001))

server.listen()

conn,addr=server.accept()

msg_1=conn.recv(1024).decode("utf-8")

msg_2=conn.recv(1024).decode("utf-8")print("客戶端>>>",msg_1)print("客戶端>>>",msg_2)

conn.close()

server.close()

黏包現象服務端

importsocketimporttime

client=socket.socket()

client.connect(('127.0.0.1', 8001))

client.send(b'123')#time.sleep(0.1) 加入時間緩沖,讓每次傳入和接受的數據有序

client.send(b'456')

client.close()

黏包現象客戶端

黏包現象粗略的解釋:數據在傳輸過程中,未來得及按照先后次序傳輸和接受,數據都進入了數據緩沖區中,再接受的數據時候,不知道按照怎么的數據長度接受,就按照給定的1024的長度接收,因此出現了黏包.

解決方案:

方案一、傳輸過程中每次都告訴對方應該如何接收數據。

方案二、把傳輸和接受的間隔加大，保證每次都能順利的滿足一個接著一個傳輸。(time.sleep(0.1))

2、大數據傳輸粘包(模擬cmd指令)

源代碼:

importsubprocessimportsocketimporttime

server=socket.socket()#創建socket對象

server.bind(('127.0.0.1',8001))#綁定ip_port

server.listen()#監聽

conn,addr=server.accept()#等待連接,獲取連接通道和地址

while 1:

time.sleep(0.1)#減少內存占用

cmd_msg=conn.recv(1024).decode("utf-8")#判斷是否結束doc指令讀取

if cmd_msg=="exit" or cmd_msg=="exit()":break

else:#創建讀取cmd指令對象

obj_sub=subprocess.Popen(

cmd_msg,

shell=True,

stdout=subprocess.PIPE,

stderr=subprocess.PIPE

)

out_info=obj_sub.stdout.read()

err_info=obj_sub.stderr.read()iferr_info:#不存在該命令則輸出錯誤信息,并打印字節數

conn.send(err_info)print(len(err_info))else:#存在輸入的命令則發送指令執行的結果,并打印字節數

conn.send(out_info)print(len(out_info))

conn.close()

server.close()

大數據黏包現象服務器

importsocket

client=socket.socket()#創建客戶端對象

client.connect(('127.0.0.1', 8001))#連接服務器的ip_port

while 1:

cmd=input("cmd>>>")

client.send(cmd.encode("utf-8"))#判斷是否為退出指令

if cmd=="exit" or cmd=="exit()":break

else:#接受客服端返回信息

out=client.recv(1024).decode("gbk")print(out)

client.close()

大數據黏包現象客戶端

結果顯示:

1 C:\Python36\python.exe "F:/qishi/day 28 黏包 合法性鏈接/黏包現象/黏包現象2客戶端.py"

2 cmd>>>ipconfig -all3

4 Windows IP 配置5

6 主機名 . . . . . . . . . . . . . : DESKTOP-MT7JLPA7 主 DNS 后綴 . . . . . . . . . . . :8 節點類型 . . . . . . . . . . . . : 混合9 IP 路由已啟用 . . . . . . . . . . : 否10 WINS 代理已啟用 . . . . . . . . . : 否11

12 無線局域網適配器 WLAN:13

14 媒體狀態 . . . . . . . . . . . . : 媒體已斷開連接15 連接特定的 DNS 后綴 . . . . . . . :16 描述. . . . . . . . . . . . . . . : Qualcomm Atheros AR9485WB-EG Wireless Network Adapter17 物理地址. . . . . . . . . . . . . : BC-30-7D-96-2D-2B18 DHCP 已啟用 . . . . . . . . . . . : 是19 自動配置已啟用. . . . . . . . . . : 是20

21 無線局域網適配器 本地連接* 1:22

23 媒體狀態 . . . . . . . . . . . . : 媒體已斷開連接24 連接特定的 DNS 后綴 . . . . . . . :25 描述. . . . . . . . . . . . . . . : Microsoft Wi-Fi Direct Virtual Adapter26 物理地址. . . . . . . . . . . . . : 1E-30-7D-96-2D-2B27 DHCP 已啟用 . . . . . . . . . . . : 是28 自動配置已啟用. . . . . . . . . . : 是29

30 以太網適配器 以太網:31

32 連接特定的 DNS 后綴 . . . . .33 cmd>>>dir34 . . :35 描述. . . . . . . . . . . . . . . : Realtek PCIe GBE Family Controller36 物理地址. . . . . . . . . . . . . : C4-54-44-F5-84-6A37 DHCP 已啟用 . . . . . . . . . . . : 是38 自動配置已啟用. . . . . . . . . . : 是39 本地鏈接 IPv6 地址. . . . . . . . : fe80::64a8:6af:a71b:edad%5(首選)40 IPv4 地址 . . . . . . . . . . . . : 192.168.12.51(首選)41 子網掩碼 . . . . . . . . . . . . : 255.255.255.0

42 獲得租約的時間 . . . . . . . . . : 2018年11月26日 15:01:29

43 租約過期的時間 . . . . . . . . . : 2018年11月27日 15:01:28

44 默認網關. . . . . . . . . . . . . : 192.168.12.254

45 DHCP 服務器 . . . . . . . . . . . : 192.168.12.254

46 DHCPv6 IAID . . . . . . . . . . . : 63198276

47 DHCPv6 客戶端 DUID . . . . . . . : 00-01-00-01-23-7C-84-72-C4-54-44-F5-84-6A48 DNS 服務器 . . . . . . . . . . . : 114.114.114.114

49 TCPIP 上的 NetBIOS . . . . . . . : 已啟用50

51 cmd>>>

客戶端顯示結果

C:\Python36\python.exe "F:/qishi/day 28 黏包 合法性鏈接/黏包現象/黏包現象2服務器.py"ipconfig-all 命令執行結果長度 1912dir 命令執行結果長度505

服務端顯示結果

現象簡述:首先執行了一次ipconfig -all,他的結果數據長度是1912,而我們接受的數據長度是1024,之后又執行了一次dir,dir結果長度是505,我們再一次接受的數據,依舊是ipconfig -all 結果數據.出現了黏包現象.

黏包現象成因:執行的數據進入緩沖區,并且數據的大小大于接受數據的大小,因此我們一次接受只能接受1024個字節,之后又執行一個命令后,命令的結果又會進入數據緩沖區,所有我們接受的數據顯示的是上一個命令殘余的數據.我們每次接受的數據都是1024,還有可能出現多命令的數據同時出現的風險.

解決方案:

方案一、按照發送數據的長度接受數據，由于緩沖區數據容量有限，我們采用循環接受數據的方法接受大數據。

方案二、把數據的長度信息與數據信息合并一次性發給接受端，接收端先提出數據長度，再按照數據長度接受數據。

方案一源代碼:

1 importsubprocess2 importsocket3 importtime4 server=socket.socket()#創建socket對象

5

6 server.bind(('127.0.0.1',8001))#綁定ip_port

7 server.listen()#監聽

8 conn,addr=server.accept()#等待連接,獲取連接通道和地址

9

10 while 1:11 time.sleep(0.1)#減少內存占用

12 cmd_msg=conn.recv(1024).decode("utf-8")13 #判斷是否結束doc指令讀取

14 if cmd_msg=="exit" or cmd_msg=="exit()":15 break

16 else:17 #創建讀取cmd指令對象

18 obj_sub=subprocess.Popen(19 cmd_msg,20 shell=True,21 stdout=subprocess.PIPE,#標準化輸出

22 stderr=subprocess.PIPE #標準化錯誤輸出

23 )24 out_info=obj_sub.stdout.read()25

26 err_info=obj_sub.stderr.read()27

28

29 iferr_info:30 #不存在該命令則輸出錯誤信息,并打印字節數

31 data_len =len(err_info)32 all_send_datalen=033 print(f"{cmd_msg} 命令執行結果長度", data_len)34 #把數據長度發送給接收端

35 conn.send(str(data_len).encode("utf-8"))36 while all_send_datalen

37 #遞增式改變截取位置

38 every_send_data=err_info[all_send_datalen:all_send_datalen+1024]39 conn.send(err_info)40 all_send_datalen+=len(every_send_data)41

42 else:43 #存在輸入的命令則發送指令執行的結果,并打印字節數

44 data_len =len(out_info)45

46 all_send_datalen =047 print(f"{cmd_msg} 命令執行結果長度:", data_len)48

49 #把數據長度發送給接收端

50 conn.send(str(data_len).encode("utf-8"))51 while all_send_datalen < data_len: #當發送的數據小于數據總長就不斷的放送

52 #遞增式改變截取位置

53 #每1024個字節發一次

54 every_send_data = out_info[all_send_datalen:all_send_datalen + 1024]55 conn.send(every_send_data)56

57 all_send_datalen +=len(every_send_data)58

59 conn.close()60 server.close()

大數據黏包服務器

1 importsocket2 client=socket.socket()#創建客戶端對象

3 client.connect(('127.0.0.1', 8001))#連接服務器的ip_port

4

5 while 1:6

7 cmd=input("cmd>>>")8 client.send(cmd.encode("utf-8"))9 #判斷是否為退出指令

10 if cmd=="exit" or cmd=="exit()":11 break

12 else:13 #客客戶端接受返回信息

14 data_len=client.recv(1024).decode("utf-8")15 int_data_len=int(data_len)16 print(int_data_len)17 #接受的字節個數,計數比較

18 all_recv_datalen=019 #用于接收到的字節拼接

20 all_data=b''

21 #循環接受數據

22 while all_recv_datalen<23>

24 every_recv_data=client.recv(1024)25 all_recv_datalen+=len(every_recv_data)26 all_data +=every_recv_data27 #輸出打印

28 print(all_data.decode("gbk"))29

30 client.close()

大數據黏包客戶端

方案二struct打包:

struct操作簡介

importstruct#打包pack#struct.pack(格式,數據)#a=231546789#b=struct.pack("i",a)#print(b)#b'\xa5\x1f\xcd\r'

#解包unpack,結果是元祖#struct.unpack(格式,數據)

c=struct.unpack("i",b'\xa5\x1f\xcd\r')print(c) #(231546789,)

a=c[0]print(a)#231546789

源碼:

importsocketimportsubprocessimportstruct

server=socket.socket()

ip_port= ('127.0.0.1',8001)

data_full_len= 0 #統計發送數據的長度

server.bind(ip_port)

server.listen()

conn,addr=server.accept()while 1:

from_client_cmd= conn.recv(1024).decode('utf-8')

sub_obj=subprocess.Popen(

from_client_cmd,

shell=True,

stdout=subprocess.PIPE,

stderr=subprocess.PIPE,

)#subprocess對象.read 得到的結果是bytes類型的

cmd_res =sub_obj.stdout.read()

data_len= len(cmd_res) #總數據長度

data_len_str =str(data_len)print('結果長度>>>',data_len)#將真實數據長度打包成4個字節的數據

struct_data_len = struct.pack('i',data_len)

conn.send(struct_data_len+ cmd_res)

大數據黏包struct服務器

importjsonimportsocketimportstruct

client=socket.socket()

ip_port= ('127.0.0.1',8001)

client.connect(ip_port)

all_recv_len=0

all_data_byte= b''

while 1:

client_cmd= input('請輸入系統指令>>>')

client.send(client_cmd.encode('utf-8'))#先接收4個字節,這4個字節是真實數據長度加工成的

recv_data_len = client.recv(4)#將4個字節長度的數據,解包成后面真實數據的長度

real_data_len = struct.unpack('i',recv_data_len)[0]print(real_data_len)

server_result=client.recv(real_data_len)print(server_result.decode('gbk'))

大數據黏包struct客戶端

加強版:

1 importstruct2 importsocket3 importsubprocess4 importtime5

6 server=socket.socket()7 server.bind(("127.0.0.1",8001))8 server.listen()9 conn,addr=server.accept()10 while 1:11 time.sleep(0.1)12 cmd_msg=conn.recv(1024).decode("utf-8")13 obj_sub=subprocess.Popen(14 cmd_msg,15 shell=True,16 stdout=subprocess.PIPE,17 stderr=subprocess.PIPE18 )19 cmd_out=obj_sub.stdout.read()20 cmd_erro=obj_sub.stderr.read()21 ifobj_sub.stdout:22 out_len=len(cmd_out)23 print(cmd_msg+"\t"+str(out_len))24 b_out_len=struct.pack("i",out_len)25 conn.send(b_out_len+cmd_out)26

27 else:28 err_len =len(cmd_erro)29 int(cmd_msg + "\t" +str(err_len))30 b_err_len = struct.pack("i", err_len)31 conn.send(b_err_len+cmd_erro)32 conn.close()33 server.close()

完整版服務器

1 importstruct2 importsocket3 importsubprocess4 importtime5

6 client=socket.socket()7 client.connect(("127.0.0.1", 8001))8 while 1:9 time.sleep(0.1)10 cmd=input("cmd>>>").encode("utf-8")11 client.send(cmd)12 #接受數據

13 data_len_pack=client.recv(4)14 data_len=struct.unpack("i",data_len_pack)[0]15 print(data_len)16 data=client.recv(data_len).decode("gbk")17 print(data)18 client.close()

完整版客服端

23>

總結

以上是生活随笔為你收集整理的python 心电处理包_python 黏包现象及其解决方案的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。