【Socket】办理UDP丢包题目

一、先容

UDP是一种不可靠的、无连接的、基于数据报的传输层协议。相比于TCP就比力简单，像写信一样，直接打包丢已往，就不用管了，而不用TCP这样的反复确认。所以UDP的优势就是速度快，开销小。但是随之而来的就是不稳固，面向无连接的，无法确认数据包。会导致丢包题目。

二、丢包缘故原由

1、服务未启动或出现故障，但是数据包依然发送出去，目标地址和端口没有任何历程在监听，这些数据包将被丢弃。
2、缓冲区满，数据包溢出丢失。在实际情况中，如果处理的速度比力慢，会导致数据包堆积在缓冲区，当缓冲区满时，发送的数据无处存放就会丢失。另一种情况是发送的数据包非常大时，可能这个数据包直接超出了缓冲区的大小，也会导致数据丢失。最后一种情况和第一种差不多，由于发送的速率过快，导致处理不及时。
Client

1. import socket
2. import time
4. def main():
5.     server_host = "127.0.0.1"
6.     server_port = 8888
8.     with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as client_sock:
9.         i = 0
10.         while True:
11.             message = b"Hello, server!"
12.             client_sock.sendto(message, (server_host, server_port))
13.             i = i + 1
14.             time.sleep(0.001)
15.             if i == 100000:
16.                 break
18. if __name__ == "__main__":
19.     main()

复制代码

Serevr

1. import socket
2. import time
4. def main():
5.     host = "127.0.0.1"
6.     port = 8888
7.     with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as server_sock:
8.         server_sock.bind((host, port))
9.         i= 0
10.         while True:
11.             data, client_addr = server_sock.recvfrom(1024)
12.             print("接收来自", client_addr, "的消息:", data.decode())
13.             if i==0:
14.                 time.sleep(10)
15.             i+=1
16.             print(i)
18. if __name__ == "__main__":
19.     main()

复制代码

这里的客户端发送了100000个数据包，在服务端特意设置处理第一个数据包后停止10秒模仿数据处理时间。在这种情况下，就会由于速度过快，缓冲区满而导致数据包丢失。服务端最后的打印为

可以看到只吸收到了96521个数据包，背面的由于缓冲区满的缘故原由全部丢失。这里不会像TCP一样堆积数据包会粘包，UDP不会，而是会一次取一个，按次序取。不同的设置的缓冲区大容量不同。
三、制止丢包

既然我们知道了丢包的缘故原由，那么在好实际开发中我们应尽量制止丢包题目。
1、在吸收端人为创建缓冲区，也即是说，如果一个数据包处理的时间很长，那么我们可以将吸收和处理分开，将吸收的数据存储到代码层面。
2、再遇见数据包很大时，可以采用分片多次传输，最后将数据在吸收端汇总处理，制止数据堆积。
3、办理方案：吸收处理分离
这里使用多历程来处理数据，与吸收数据使用不同的线程，互不影响，这样不会导致数据包的吸收速度，所以缓冲区不会堆积，制止数据包的丢失。手动创建了一个当地数据缓冲区，使用一个列表将吸收的数据存储，使用多历程不断处理。这里相当于队列是一个当地缓冲区，可以制止数据丢包，但是需要留意的是当地缓冲区不能也不能凌驾大小。
Client

1. import socket
2. import time
4. def main():
5.     server_host = "127.0.0.1"
6.     server_port = 8888
8.     with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as client_sock:
9.         i = 0
10.         while True:
11.             message = b"Hello, server!"
12.             client_sock.sendto(message, (server_host, server_port))
13.             i = i + 1
14.             time.sleep(0.001)
15.             if i == 100000:
16.                 break
18. if __name__ == "__main__":
19.     main()

复制代码

Server

1. from multiprocessing import Queue
2. import socket
3. import time
4. from  multiprocessing import Process
6. def task(data_list:Queue):
7.     '''模拟处理处理'''
8.     while True:
9.         data = data_list.get()
10.         time.sleep(10)
11.      
12. def main():
13.     host = "127.0.0.1"
14.     port = 8888
15.     data_list = Queue()
16.     i= 0
17.     work = Process(target=task, args=(data_list,))
18.     work.daemon = True
19.     work.start()   
20.     with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as server_sock:
21.         server_sock.bind((host, port))
22.         while True:
23.             data, _ = server_sock.recvfrom(1024)
24.             data_list.put(data)
25.             i+=1
26.             print(i)
28. if __name__ == "__main__":
29.     main()

复制代码

四、办理丢包

1、复兴机制

Server

1. import socket
3. def main():
4.     host = "127.0.0.1"
5.     port = 8888
6.     with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as server_sock:
7.         server_sock.bind((host, port))
8.         while True:
9.             data, client_addr = server_sock.recvfrom(1024)
10.             print("接收到来自", client_addr, "的消息:", data.decode())
11.             ack_message = "ACK".encode()
12.             server_sock.sendto(ack_message, client_addr)
14. if __name__ == "__main__":
15.     main()

复制代码

Client
[code]import socketimport timedef main():    server_host = "127.0.0.1"    server_port = 8888    message = ["Hello, server!"]*10    timeout = 2     i = 0    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as client_sock:        client_sock.settimeout(timeout)        while i