欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

第二十八天- tcp下的粘包和解决方案

程序员文章站 2022-06-20 11:40:25
1.什么是粘包 写在前面:只有TCP有粘包现象,UDP永远不会粘包 1.TCP下的粘包 因为TCP协议是面向连接、面向流的,收发两端(客户端和服务器端)都要有成对的socket,因此,发送端为了将多个发往接收端的包,更有效的发到对方,使用了优化方法(Nagle算法),将多次间隔较小且数据量小的数据, ......

 

1.什么是粘包

  写在前面:只有tcp有粘包现象,udp永远不会粘包

  1.tcp下的粘包

  因为tcp协议是面向连接、面向流的,收发两端(客户端和服务器端)都要有成对的socket,因此,发送端为了将多个发往接收端的包,更有效的发到对方,使用了优化方法(nagle算法),将多次间隔较小且数据量小的数据,合并成一个大的数据块,然后进行封包,这就导致了数据量小的粘包现象;同时因为tcp的协议的安全可靠性,在没有收完包,下次接收,会继续上次继续接收,己端总是在收到ack时才会清除缓冲区内容。数据是可靠的,但是会导致数据量大的粘包;

第二十八天- tcp下的粘包和解决方案

  2.udp没粘包原因:

  udp是无连接的,面向消息的,为提供高效率服务 ,并不会使用块的合并优化算法;同时由于udp支持一对多的模式,所以接收端缓冲区采用了链式结构来记录每一个到达的udp包,也就是在每个udp包中有头(消息来源地址,端口等信息),这样,对于接收端来说就是有边界的,所以udp永远没粘包。 

 

 

2.两种粘包情况  

  1.情况一 发送方的缓存机制
  发送端需要等缓冲区满才发送出去,造成粘包(发送数据时间间隔很短,数据了很小,优化机制会合到一起,产生粘包)

第二十八天- tcp下的粘包和解决方案
 1 # 连续传小包被优化机制合并导致的粘包
 2 
 3 import socket
 4 
 5 server = socket.socket()
 6 ip_port = ('127.0.0.1',8081)
 7 server.bind(ip_port)
 8 server.listen()
 9 conn,addr = server.accept()
10 
11 from_client_msg1 = conn.recv(1024).decode('utf-8')
12 from_client_msg2 = conn.recv(1024).decode('utf-8')
13 
14 print(from_client_msg1)
15 print(from_client_msg2)
16 # heheheenenen  两条消息被优化合并在了一块
17 
18 conn.close()
19 server.close()
view 小数据粘包_server code
第二十八天- tcp下的粘包和解决方案
 1 import socket
 2 
 3 client = socket.socket()
 4 ip_port = ('127.0.0.1',8081)
 5 client.connect(ip_port)
 6 
 7 to_server_msg1 = client.send(b'hehehe')
 8 to_server_msg2 = client.send(b'enenen')
 9 
10 client.close()
view 小数据粘包_client code

 

  2.情况二 接收方的缓存机制

  接收方不及时接收缓冲区的包,造成多个包接收(客户端发送了一段数据,服务端只收了一小部分,服务端下次再收的时候还是从缓冲区拿上次遗留的数据,产生粘包)

第二十八天- tcp下的粘包和解决方案
 1 # 传输数据超出接收范围导致的粘包
 2 import socket
 3 import subprocess
 4 
 5 server = socket.socket()
 6 ip_port = ('127.0.0.1',8001)
 7 server.bind(ip_port)
 8 server.listen()
 9 conn,addr = server.accept()
10 
11 while 1:
12     from_client_cmd = conn.recv(1024).decode('utf-8')
13 
14     sub_obj = subprocess.popen(
15         from_client_cmd,
16         shell=true,
17         stdout=subprocess.pipe,
18         stderr=subprocess.pipe,
19     )
20     cmd_res = sub_obj.stdout.read()
21     print('结果长度>>>', len(cmd_res))
22     conn.send(cmd_res)  # 发内容给客户端
数据大粘包_server
第二十八天- tcp下的粘包和解决方案
 1 import socket
 2 
 3 client = socket.socket()
 4 ip_port = ('127.0.0.1',8001)
 5 client.connect(ip_port)
 6 
 7 
 8 while 1:
 9     client_cmd = input('请输入系统指令>>>')
10     client.send(client_cmd.encode('utf-8'))
11 
12     from_server_msg = client.recv(1024)  # 接收返回的消息
13 
14     print(from_server_msg.decode('gbk'))
15     # 可以看到没一次性接收完毕,执行下条命令出现了上次的结果,这就是数据大超出接收范围的粘包。
数据大粘包_client

 

  3.总结

  黏包现象只发生在tcp协议中:

  1.从表面上看,黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。

  2.实际上,主要还是因为接收方不知道消息间的界限,不知道一次性提取多少字节的数据所造成。

 

 

3.粘包解决方案

 

  1.解决方案一:
  问题的根源在于,接收端不知道发送端将要传送的字节流的长度,所以解决粘包的方法就是围绕,如何让发送端在发送数据前,把自己将要发送的字节流总大小让接收端知晓,然后接收端来一个死循环接收完所有数据。

第二十八天- tcp下的粘包和解决方案

第二十八天- tcp下的粘包和解决方案
 1 import socket
 2 import subprocess
 3 
 4 server = socket.socket()
 5 ip_port = ('127.0.0.1',8001)
 6 server.bind(ip_port)
 7 server.listen()
 8 conn,addr = server.accept()
 9 
10 while 1:
11     from_client_cmd = conn.recv(1024).decode('utf-8')  # 接收传来的命令
12     sub_obj = subprocess.popen(
13         from_client_cmd,
14         shell=true,
15         stdout=subprocess.pipe,
16         stderr=subprocess.pipe,
17     )
18     # subprocess对象.read 得到命令结果,是bytes类型的
19     str_byt = sub_obj.stdout.read()
20     str_len = len(str_byt)
21     print(str_len)
22     conn.send(str(str_len).encode('utf-8'))  # 先发长度
23 
24     from_client_msg = conn.recv(1024).decode('utf-8')
25     if from_client_msg == 'ok':
26         conn.send(str_byt)  # 客户端确认收到长度后 再发送真实内容
27     else:
28         print("客户端未收到长度!")
29         break
30 
31 conn.close()
32 server.close()
解决小包粘包_服务端
第二十八天- tcp下的粘包和解决方案
 1 import socket
 2 
 3 client = socket.socket()
 4 ip_port = ('127.0.0.1',8001)
 5 client.connect(ip_port)
 6 
 7 
 8 while 1:
 9     client_cmd = input('请输入系统指令>>>')
10     client.send(client_cmd.encode('utf-8'))
11 
12     from_server_len = client.recv(1024).decode('utf-8')  # 接收返回的长度
13     print(from_server_len)
14     client.send(b'ok')
15 
16     from_server_msg = client.recv(int(from_server_len))  # 注意还原成int
17     print(from_server_msg.decode('gbk'))
解决小包粘包_客户端

  不足之处:程序的运行速度远快于网络传输速度,所以在发送一段字节前,先用send去发送该字节流长度,这种方式会放大网络延迟带来的性能损耗

 

  2.解决方案进阶:
  可借助struct模块,这个模块可把要发的数据长度转成固定长度字节。这样客户端每次接收消息前只要先收到这个固定长度字节的内容,收到接下来要接收的信息大小,那么最终接受的数据只要达到这个值就停止,就能完整接收的数据了。

  struct模块:该模块可以把一个类型,如数字,转成固定长度的bytes

1 import struct
2 
3 res = struct.pack('i',1111111)  # i 模式  1111111 要转换的内容
4 print(res)  # b'g\xf4\x10\x00'

  模式,见下图:

第二十八天- tcp下的粘包和解决方案

 

第二十八天- tcp下的粘包和解决方案
 1 import socket
 2 import struct
 3 import subprocess
 4 
 5 server = socket.socket()
 6 ip_port = ('127.0.0.1',8001)
 7 server.bind(ip_port)
 8 server.listen()
 9 conn,addr = server.accept()
10 
11 while 1:
12     from_client_cmd = conn.recv(1024).decode("utf-8") # 注意转码
13     # print(from_client_cmd)
14     sub_obj = subprocess.popen(
15         from_client_cmd,
16         shell=true,
17         stdout=subprocess.pipe,
18         stderr=subprocess.pipe,
19     )
20     cmd_res = sub_obj.stdout.read()  # 得到bytes类型所有内容
21     str_len = len(cmd_res)
22     print(str_len)
23 
24     str_len1 = struct.pack('i',str_len)  # 把长度打包成4字节的bytes
25 
26     conn.send(str_len1 + cmd_res)  # 拼接字节 把长度和内容打包发给客户端
struct方案解决粘包_server
第二十八天- tcp下的粘包和解决方案
 1 import socket, struct
 2 
 3 client = socket.socket()
 4 ip_port = ('127.0.0.1',8001)
 5 client.connect(ip_port)
 6 
 7 while 1:
 8     str_cmd = input('请输入命令>>> ').encode('utf-8')
 9     client.send(str_cmd)
10     # 先接收4个字节,4个字节是数据的真实长度转换而成的
11     str_len = client.recv(4)
12     # print(str_len)
13     num = struct.unpack('i',str_len)[0]  # 注意解出来是一个元组 用下标把真实长度取出来
14 
15     print(num)
16 
17     str_res = client.recv(num)
18     print(str_res.decode('gbk'))
struct方案解决粘包_client

 

补充:获取缓冲区大小

1 # 获取socket缓冲区大小
2 import socket
3 from socket import sol_socket,so_reuseaddr,so_sndbuf,so_rcvbuf
4 sk = socket.socket(type=socket.sock_dgram)
5 # sk.setsockopt(sol_socket,so_rcvbuf,80*1024)
6 sk.bind(('127.0.0.1',8090))
7 print('>>>>', (sk.getsockopt(sol_socket, so_sndbuf))/1024)
8 print('>>>>', sk.getsockopt(sol_socket, so_rcvbuf))