python套接字解决tcp粘包问题

python套接字解决tcp粘包问题

目录

1
2
3
4
5
什么是粘包<br><br>演示粘包现象
 
解决粘包
 
实际应用

 

 

 

什么是粘包

首先只有tcp有粘包现象,udp没有粘包

 

 

socket收发消息的原理

 

 

1
2
3
发送端可以是一K一K地发送数据,而接收端的应用程序可以两K两K地提走数据,当然也有可能一次提走3K或6K数据,或者一次只提走几个字节的数据,也就是说,应用程序所看到的数据是一个整体,或说是一个流(stream),<br>一条消息有多少字节对应用程序是不可见的,因此TCP协议是面向流的协议,这也是容易出现粘包问题的原因。而UDP是面向消息的协议,每个UDP段都是一条消息,应用程序必须以消息为单位提取数据,不能一次提取任意字节<br>的数据,这一点和TCP是很不同的。怎样定义消息呢?可以认为对方一次性write/send的数据为一个消息,需要明白的是当对方send一条信息的时候,无论底层怎样分段分片,TCP协议层会把构成整条消息的数据段排序完成后<br>才呈现在内核缓冲区。
 
例如基于tcp的套接字客户端往服务端上传文件,发送时文件内容是按照一段一段的字节流发送的,在接收方看了,根本不知道该文件的字节流从何处开始,在何处结束

 

粘包问题的根源

1
所谓粘包问题主要还是因为接收方不知道消息之间的界限,不知道一次性提取多少字节的数据所造成的。此外,发送方引起的粘包是由TCP协议本身造成的,TCP为提高传输效率,发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少,通常TCP会根据优化算法把这些数据合成一个TCP段后一次发<br>送出去,这样接收方就收到了粘包数据。

 

tcp和udp协议

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

 

 

补充

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
拆包的发生情况
 
当发送端缓冲区的长度大于网卡的MTU时,tcp会将这次发送的数据拆成几个数据包发送出去。<br>
 
补充问题一:为何tcp是可靠传输,udp是不可靠传输
 
基于tcp的数据传输请参考另一篇文章http://www.cnblogs.com/linhaifeng/articles/5937962.html,tcp在数据传输时,发送端先把数据发送到自己的缓存中,然后协议控制将缓存中的数据发往对端,对端返回<br>一个ack=1,发送端则清理缓存中的数据,对端返回ack=0,则重新发送数据,所以tcp是可靠的
 
而udp发送数据,对端是不会返回确认信息的,因此不可靠<br>
 
补充问题二:send(字节流)和recv(1024)及sendall
 
recv里指定的1024意思是从缓存里一次拿出1024个字节的数据
 
send的字节流是先放入己端缓存,然后由协议控制将缓存内容发往对端,如果待发送的字节流大小大于缓存剩余空间,那么数据丢失,用sendall就会循环调用send,数据不会丢失

  

 

总结

1
2
3
udp的recvfrom是阻塞的,一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失,这意味着udp根本不会粘包,但是会丢数据,不可靠
 
tcp的协议数据不会丢,没有收完包,下次接收,会继续上次继续接收,己端总是在收到ack时才会清除缓冲区内容。数据是可靠的,但是会粘包。<br><br>

  

 

 

演示粘包现象

 

两种情况下会发生粘包

1
2
3
4
发送端需要等缓冲区满才发送出去,造成粘包(发送数据时间间隔很短,数据量很小,会合到一起,产生粘包),这是由于tcp的优化算法。
 
 
接收方不及时接收缓冲区的包,造成多个包接收(客户端发送了一段数据,服务端只收了一小部分,服务端下次再收的时候还是从缓冲区拿上次遗留的数据,产生粘包)

  

 

 

第一种情况

客户端多次间隔时间短,数据量小的发送数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#服务端<br>import socket
 
 
def main():
    ip_port= ('127.0.0.1',4444)
    back_log=5
    buffer_size=1024
 
    s1 = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #基于tcp的网络通信
    s1.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
    s1.bind(ip_port) #绑定ip和端口
    s1.listen(back_log)  # 最多连接几个客户端
    conn, addr = s1.accept()
 
    data1=conn.recv(buffer_size)
    data2=conn.recv(buffer_size)
    data3=conn.recv(buffer_size)
    print('第一次',data1.decode('utf-8'))
    print('第二次',data2.decode('utf-8'))
    print('第三次',data3.decode('utf-8'))
    conn.close()
    s1.close()
 
if __name__ == '__main__':
    main()

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#客户端
import socket
 
 
def main():
    ip_port = ('127.0.0.1', 4444)
 
    buffer_size = 1024
 
    s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
    s2.connect(ip_port)  # 连接服务端
 
    data1 = 'hello'
    s2.send(data1.encode('utf-8'))
    data2 ='wrold'
    s2.send(data2.encode('utf-8'))
    data3 = 'pop'
    s2.send(data3.encode('utf-8'))
    s2.close()
 
if __name__ == '__main__':
    main()

 

 

演示

可以看出来服务端在第一次就把三次发送的数据都接收了,这就是粘包,服务端不知道一次读取多少的数据,一次全部读取出来。

首先我们要知道并不是客户端发几次,服务端就要接收几次,一次发的数据也可以三次读取出来,收发信息都是从自己的内核缓存区读取。

 

 

第二种情况

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#服务端<br>import socket
 
 
def main():
    ip_port= ('127.0.0.1',4444)
    back_log=5
    buffer_size=1024
 
    s1 = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #基于tcp的网络通信
    s1.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
    s1.bind(ip_port) #绑定ip和端口
    s1.listen(back_log)  # 最多连接几个客户端
    conn, addr = s1.accept()
 
    data1=conn.recv(5)
    data2=conn.recv(buffer_size)
    
    print('第一次',data1.decode('utf-8'))
    print('第二次',data2.decode('utf-8'))
   
    conn.close()
    s1.close()
 
if __name__ == '__main__':
    main()
 
 
<br>#客户端
import socket
 
 
def main():
    ip_port = ('127.0.0.1', 4444)
 
    
 
    s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
    s2.connect(ip_port)  # 连接服务端
 
    data1 = 'hellowroldpop'
    s2.send(data1.encode('utf-8'))
    s2.close()
 
if __name__ == '__main__':
    main()

 

 

演示

服务端读取数据没有全部读取出来,导致第一次应该接收完的数据还要第二次读取出来

 

 

 

 

 

解决粘包

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

 

第一种解决方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#服务端
import socket
 
 
def main():
    ip_port = ('127.0.0.1', 4444)
    back_log = 5
    buffer_size = 1024
 
    s1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 基于tcp的网络通信
    s1.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s1.bind(ip_port)  # 绑定ip和端口
    s1.listen(back_log)  # 最多连接几个客户端
    conn, addr = s1.accept()
 
    while True:
     #接收数据大小
        length= conn.recv(buffer_size).decode('utf-8')<br>     #为防止客户端连续发包,回应
        conn.send('ready'.encode('utf-8'))
        length=int(length)
 
        recv_size=0   #已经接收到数据的大小
        recv_msg=b''  #已经接收到的数据<br>
     #接收数据
        while recv_size<length:
            r_msg = conn.recv(buffer_size)
            recv_msg+=r_msg
            recv_size +=len(r_msg)
       #另一种方法接收数据的方法<br>
            #recv_msg+=conn.recv(buffer_size)
            #recv_size=len(recv_msg)
 
 
 
 
    s1.close()
 
 
if __name__ == '__main__':
    main()

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#客户端
import socket
 
 
def main():
    ip_port = ('127.0.0.1', 4444)
 
    buffer_size = 1024
 
    s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
    s2.connect(ip_port)  # 连接服务端
 
    while True:
 
        data1 = input('input:')<br>     #将数据大小转为字符型然后编码发出去
        s2.send(str(len(data1)).encode('utf-8'))<br>      #接收服务端的回应
        server_Ready=s2.recv(buffer_size)<br>      #接收到服务端回应
        if server_Ready==b'ready':
            s2.send(data1.encode('utf-8'))
    s2.close()
 
 
if __name__ == '__main__':
    main()

 

1
2
3
4
5
总结:客户端在发送数据时,先发送数据大小,这时不能把数据内容一起发送出去,服务端第一次接收的时候,并不知道该读取多少的数据大小和多少的数据内容,所以还是会造成粘包,我们的解决办法是,服务端获取到数据大小后,要回应一次,然后根据数据大小来循环读取内容。
 
这种方法不好,需要服务端多发一次回应,这很影响服务端的性能。
 
程序的运行速度远快于网络传输速度,所以在发送一段字节前,先用send去发送该字节流长度,这种方式会放大网络延迟带来的性能损耗

  

 

 

第二种解决方法

为字节流加上自定义固定长度报头,报头中包含字节流长度,然后一次send到对端,对端在接收时,先从缓存中取出定长的报头,然后再取真实数据

 

struct模块 

1
2
3
4
5
该模块可以把一个类型,如数字,转成固定长度的bytes
 
>>> struct.pack('i',1111111111111) #第一个参数是要封装的格式类型,第二个参数是要封装的内容
 
struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #这个封装数据的范围,只要在这个范围里面,就可以把内容封装成固定大小

 

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#服务端
 
import socket
import struct
 
 
def main():
    ip_port = ('127.0.0.1', 4444)
    back_log = 5
    buffer_size = 1024
 
    s1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 基于tcp的网络通信
    s1.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s1.bind(ip_port)  # 绑定ip和端口
    s1.listen(back_log)  # 最多连接几个客户端
    conn, addr = s1.accept()
 
    while True:
 
        length_data= conn.recv(4)
        length=struct.unpack('i',length_data)[0]
 
        recv_size=0   #已经接收到数据的大小
        recv_msg=b''  #已经接收到的数据
 
        while recv_size<length:
            r_msg = conn.recv(buffer_size)
            recv_msg+=r_msg
            recv_size +=len(r_msg)
 
            #recv_msg+=conn.recv(buffer_size)
            #recv_size=len(recv_msg)
 
 
    s1.close()
 
 
if __name__ == '__main__':
    main()

  

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#客户端
 
import socket
import struct
 
 
def main():
    ip_port = ('127.0.0.1', 4444)
 
    buffer_size = 1024
 
    s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
    s2.connect(ip_port)  # 连接服务端
 
    while True:
 
        data1 = input('input:')
        length=len(data1)
        #定制包头 i为4个字节,所以接收方为四个字节,这个大小并不是输入的大小,而是封装固定的大小
        data_length=struct.pack('i',length) #使用struct,直接将int转为二进制型数据传输,对方使用struct解包
        s2.send(data_length)
 
        s2.send(data1.encode('utf-8'))
    s2.close()
 
 
if __name__ == '__main__':
    main()

  

 

1
总结:客户端把数据长度封装成一个固定大小的数据,这时服务端就可以指定读取固定大小的内容,不会读取数据的内容,服务端只要根据数据长度再来接收数据内容就好了,所以客户端连续两次发数据,不会粘包,因为服务<br>端每次接收都只接收了本次该接收的数据。<br><br>

  

 

 

实际应用

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#服务端<br>from socket import  *
import subprocess
import struct
 
 
def main():
    ip_port=('127.0.0.1',8080)
    back_log=5
    buffer_size=1024
 
 
    s1 = socket(AF_INET,SOCK_STREAM)
    s1.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
    s1.bind(ip_port)
    s1.listen(back_log)
 
    while True:
        conn,addr=s1.accept()
 
        while True:
            try:
                #收信息
                 cmd = conn.recv(buffer_size)
                 if not cmd:break
                 print('收到的命令是:',cmd.decode('utf-8'))
 
 
                 #执行命令
                 res = subprocess.Popen(cmd.decode('utf-8'),shell=True,
                                        stderr=subprocess.PIPE,
                                        stdout=subprocess.PIPE,
                                        stdin=subprocess.PIPE)
 
                 err = res.stderr.read()
                 if  err:
                     cmd_res=err
                 else:
                     cmd_res=res.stdout.read()
 
                 if not cmd_res:
                     cmd_res='执行成功'.encode('gbk')
 
                 length=len(cmd_res)
                #第一次发送数据大小
                 data_length = struct.pack('i', length)  # 使用struct,直接将int转为二进制型数据传输,对方使用struct解包
                 conn.send(data_length)
                #发信息
                #注意:执行的结果默认jbk编码方式,所以客户端必须使用gbk方式解码
                 conn.send(cmd_res)
 
            except Exception:
                break
        conn.close()
    s1.close()  # 关闭服务端套接字
 
 
if __name__ == '__main__':
    main()

  

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#客户端<br>from socket import  *
import struct
 
 
def main():
    ip_port=('127.0.0.1',8080)
    buffer_size=1024
 
    s1 = socket(AF_INET,SOCK_STREAM)
    s1.connect(ip_port)
 
    while True:
        cmd = input('-->')
        if not cmd:continue
        if cmd =='quite':break
        s1.send(cmd.encode('utf-8'))
        length_data =s1.recv(4)
        length = struct.unpack('i', length_data)[0]
 
        recv_size = 0  # 已经接收到数据的大小
        recv_msg = b''  # 已经接收到的数据
 
        while recv_size < length:
            r_msg = s1.recv(buffer_size)
            recv_msg += r_msg
            recv_size += len(r_msg)
 
 
            # recv_msg+=conn.recv(buffer_size)
            # recv_size=len(recv_msg)
 
        print('命令执行结果:',recv_msg.decode('gbk'))
 
    s1.close()
 
if __name__=='__main__':
    main()

 

总结

1
2
3
4
5
6
7
如果没有粘包的处理
 
服务端把命令执行的结果发给客户端的时候,数据太大,客户端一次没有接收完,在客户端第二次执行命令的时候,就会把第一次没有读取完的部分也读取出来,这属于我们刚才说的第二种粘包的情况。
 
有了粘包的处理
 
只要服务端把结果发过来,就算超过网卡的限制(拆包发送),客户端能保证在循环的过程中接收完结果

  

 

posted @   -零  阅读(2390)  评论(0编辑  收藏  举报
编辑推荐:
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
· AI与.NET技术实操系列:向量存储与相似性搜索在 .NET 中的实现
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列:如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
阅读排行:
· TypeScript + Deepseek 打造卜卦网站:技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配,妙~啊~
· .NET Core 中如何实现缓存的预热?
点击右上角即可分享
微信分享提示