🌠前言

基于udp的socket服务有什么特点？黏包现象是什么？又是如何产生的？udp和tcp哪种会有黏包现象？看完这篇文章相信你会有所收获。

目录

🌠一、基于udp的socket服务

🌠二、TCP中的黏包现象

🌠三、基于UDP协议实现的黏包

🌠四、黏包现象产生原因

☄️4.1、tcp协议的特点

☄️4.2、Nagle算法和面向流的通信特点

☄️4.3、tcp协议的拆包机制

☄️4.4、udp协议的特点

☄️4.5、总结黏包两种情况

☄️4.6、黏包现象的触发

🌠一、基于udp的socket服务

使用UDP协议需要注意几点：

①UDP是面向无连接的,客户端在于服务器通信前无须建立连接,且UDP协议不保证发出的消息是否被收到,是否有丢失。

②UDP的接收和发送信息使用recvfrom()与sendto()函数

写UDP时的关键点

udp的server不需要监听也不需要建立连接，在启动服务之后只能被动的等待客户端发送消息过来，与此同时客户端发送消息的同时还会自带地址信息，消息回复的同时不仅需要发送消息，还需要把自己的地址发送过去

一个最简单的实现udp的socket服务的例子

client.py

import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
ip_port = ('127.0.0.1',8080)    #要发送对象的ip地址

sk.sendto(b'hello',ip_port)
ret,addr = sk.recvfrom(1024)    #将自己的地址发送
print('服务端地址：',addr)    #结果：服务端地址： ('127.0.0.1', 8080)
print(ret.decode('utf-8'))

sk.close()

server.py

import socket
sk = socket.socket(type=socket.SOCK_DGRAM) #dategram
sk.bind(('127.0.0.1',8080))
msg,addr = sk.recvfrom(1024)
print('客户端地址：',addr)      #结果：客户端地址： ('127.0.0.1', 52256)
print(msg.decode('utf8'))
sk.sendto(b'bye',addr)
sk.close()

🌠二、TCP中的黏包现象

tcp_server.py

import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
conn,addr = sk.accept()

while 1:
    cmd = input('>>>')
    conn.send(cmd.encode('utf8'))
    ret = conn.recv(1024).decode('utf8','ignore')
    print(ret)

conn.close()
sk.close()

#接收的数据发生错乱，数据接收多了，或者没接收完
#黏包现象

tcp_client.py

import socket
import subprocess
sk = socket.socket()
sk.connect(('127.0.0.1',8080))

while 1:
    cmd = sk.recv(1024).decode('gbk')
    ret = subprocess.Popen(cmd,shell=True,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE)
    std_out = 'stdout :' + (ret.stdout.read()).decode('gbk')
    std_err = 'stderr :' + (ret.stderr.read()).decode('gbk')
    print(std_out)
    print(std_err)

    sk.send(std_out.encode('utf8'))
    sk.send(std_err.encode('utf8'))

sk.close()

🌠三、基于UDP协议实现的黏包

提前说明：TCP是会粘包，UDP永远不会粘包

udp_server.py

import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()
conn,addr = sk.accept()

while 1:
    cmd = input('>>>')
    conn.send(cmd.encode('utf8'))
    ret = conn.recv(1024).decode('utf8','ignore')
    print(ret)

conn.close()
sk.close()

#接收的数据发生错乱，数据接收多了，或者没接收完
#黏包现象，但是在UDP中就不会发生黏包现象，因为UDP上一次的消息没发完就直接丢失了

udp_client.py

import socket
import subprocess
sk = socket.socket()
sk.connect(('127.0.0.1',8080))

while 1:
    cmd = sk.recv(1024).decode('gbk')
    ret = subprocess.Popen(cmd,shell=True,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE)
    std_out = 'stdout :' + (ret.stdout.read()).decode('gbk')
    std_err = 'stderr :' + (ret.stderr.read()).decode('gbk')
    print(std_out)
    print(std_err)

    sk.send(std_out.encode('utf8'))
    sk.send(std_err.encode('utf8'))

sk.close()

🌠四、黏包现象产生原因

☄️4.1、tcp协议的特点

是因为TCP协议是面向流的协议，在发送的数据传输的过程中还有缓存机制来避免数据丢失

因为在连续发送小数据的时候、以及接收大小不符的时候都容易出现黏包现象，本质还是因为我们在接收数据的时候不知道发送的数据的长短

☄️4.2、Nagle算法和面向流的通信特点

tcp协议内部有Nagle算法这个优化算法，

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。
收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。
这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。 
对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），也可以被发送，udp协议会帮你封装上消息头发送过去。 
可靠黏包的tcp协议：tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

☄️4.3、tcp协议的拆包机制

当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。 
MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。大部分网络设备的MTU都是1500。
如果本机的MTU比网关的MTU大，大的数据包就会被拆开来传送，这样会产生很多数据包碎片，增加丢包率，降低网络速度

☄️4.4、udp协议的特点

UDP传输的特点是快速，无时延，但传输时无序、无流量控制、不可靠

☄️4.5、总结黏包两种情况

• 一种是因为发送数据包时，每次发送的包小，因为系统进行优化算法，就将两次的包放在一起发送，减少了资源的重复占用。多次发送会经历多次网络延迟，一起发送会减少网络延迟的次数。因此在发送小数据时会将两次数据一起发送，而客户端接收时，则会一并接收。#即出现多次send会出现黏包
• 第二种是因为接收数据时，又多次接收，第一次接收的数据量小，导致数据还没接收完，就停下了，剩余的数据会缓存在内存中，然后等到下次接收时和下一波数据一起接收。

☄️4.6、黏包现象的触发

server.py

#在Windows高版本上长链接关闭，
# 但是服务端仍要接收消息，此时就会默认发送空消息
import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8080))
sk.listen()

conn,addr = sk.accept()
ret1 = conn.recv(12)
print(ret1)
ret2 = conn.recv(12)
print(ret2)     #接收到了一个空消息
ret3 = conn.recv(12)
print(ret3)
conn.close()
sk.close()

#多个send小的数据连在一起，会发生黏包现象，是tcp协议内部的优化算法造成的
#连续使用了send

 client.py

import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8080))

sk.send(b'hello')
sk.send(b'egg')


import time
time.sleep(5)
sk.close()