1、UDP程式設計：

　　測試命令：

　　　　windows：

　　　　　　　netstat  -anp udp | findstr 9999
　　　　Linux: 發給伺服器資料

　　　　　　echo '233' | nc -u 127.0.0.1 9999

2、UDP伺服器端程式設計：

　　UDP伺服器端程式設計流程：（從圖中可以看到，伺服器端只需要一個socket）

• • • 建立socket 物件，socket.SOCK_DGRAM
    • 繫結IP 和 Port， bind() 方法
    • 傳輸資料：
      • 接受資料：socket.recvfrom(bufsize [, flags] ) ,獲取一個二元組（）
      • 傳送資料：socket.sendto(string, address) 發給某地址某資訊
    • 釋放資源　　　　　

 1 import socket
 2 
 3 socket = socket.socket(type=socket.SOCK_DGRAM)
 4 
 5 ip = '127.0.0.1'
 6 port = 9999
 7 
 8 laddr = ip, port
 9 
10 socket.bind(laddr) #  伺服器端正式啟動
11 
12 data, raddr = socket.recvfrom(1024) #
 
 沒有接收到，會處於阻塞狀態
13 
14 socket.sendto(data, raddr)
15 
16 socket.close()

　　UDP客戶端程式設計流程：

　　　　注意：UDP是無連線協議，多以可以只有任何一端，例如客戶端資料發往服務端，伺服器端存在與否無所謂。

　　UDP程式設計中bind、connect、send、sendto、recv、recfrom方法使用

　　UDP的socket物件建立後，是麼有佔用本地地址額埠的

　　　　注意：

　　　　　　1、UDP 建立socket後，不能直接recv，recvfrom，，只有知道了本地地址和埠，伺服器端才能知道資料應該發給你

　　　　　　2、send 和 connect 搭配使用。

 　　心跳機制：

　　　　加一個ack機制 和 心跳 hearbeat

　　　　心跳，就是一端定時的發往另一端的資訊，一般每次資料越少越好，心跳時間間隔約定好就行。

　　　　ack 即響應，一端收到另一端的訊息後返回的確認訊息

　　　　心跳機制：

1. 1. 一般來說是客戶端定時發往伺服器端的，伺服器端並不需要ACK 回覆客戶端，只需要記錄該客戶端還活著就行（比如群聊，如果客戶端不活著，就沒必要回復）
   2. 如果是伺服器端定時發往客戶端的，一般需要 客戶端ack 響應，表示活著，，如果沒有收到ack的客戶端，伺服器端移除其資訊，這種實現比較複雜，較少使用。
   3. 也就是雙向都發送心跳，很少使用

UDP實現群聊：

　　server端：

 1 import socket
 2 import threading
 3 import logging
 4 import datetime
 5 
 6 
 7 FORMAT = '%(asctime)s %(thread)s %(threadName)s %(message)s'
 8 logging.basicConfig(format=FORMAT, level=logging.INFO)
 9 
10 class ChatServer:
11     def __init__(self, ip='127.0.0.1', port=9999, interval=10):
12         self.laddr = ip, port
13         self.event = threading.Event()
14         self.sock = socket.socket(type=socket.SOCK_DGRAM)
15         self.clients = {}
16         self.interval = interval
17 
18     def start(self):
19         self.sock.bind(self.laddr)
20 
21         threading.Thread(target=self.recv, name='recvive').start()
22 
23     def recv(self):
24         while not self.event.is_set():
25             data, raddr = self.sock.recvfrom(1024)
26             localkeys = set()
27             logging.info(data)
28 
29             # 心跳資訊
30             if data.strip() == b'^hb^':
31                 self.clients[raddr] = datetime.datetime.now().timestamp()
32                 continue
33 
34             if data.strip() == b'quit':
35                 # 若一個客戶端剛進來，還沒有加到字典中，直接pop，會報KerryError
36                 # if raddr in self.clients.keys():
37                 self.clients.pop(raddr, None)
38                 continue
39             self.clients[raddr] = datetime.datetime.now().timestamp()
40 
41             # z再次傳送資料的時間，如果之後沒有再次進入，這次的時間就作為下次比較時間，所以這次的時間可以認為是最新的心跳資訊
42             current = datetime.datetime.now().timestamp()
43             msg = '{}--{}'.format(data.decode(), '******').encode()
44 
45             # 過期的就不在發資料給客戶端了，並且剔除掉
46             #z 字典不能再遍歷的時候，刪除內容
47             for r, t in self.clients.items():
48                 if current - t > self.interval:
49                     localkeys.add(r)
50                 self.sock.sendto(msg, r)
51             for r in localkeys:
52                 self.clients.pop(r)
53 
54     def stop(self):
55         self.sock.close()
56         self.event.set()
57 
58 
59 def main():
60     cs = ChatServer()
61     cs.start()
62 
63     while True:
64         cmd = input(">>>")
65         if cmd == 'quit':
66             cs.stop()
67             break
68         logging.info(threading.enumerate())
69 
70 
71 if __name__ == "__main__":
72     main()

　　client端：

 1 import socket
 2 import threading
 3 import logging
 4 import datetime
 5 
 6 
 7 FORMAT = '%(asctime)s %(thread)s %(threadName)s %(message)s'
 8 logging.basicConfig(format=FORMAT, level=logging.INFO)
 9 
10 class ChatClient:
11     def __init__(self, ip='127.0.0.1', port=9999, interval=3):
12         self.raddr = ip, port
13         self.event = threading.Event()
14         self.sock = socket.socket(type=socket.SOCK_DGRAM)
15         self.interval = interval
16 
17     def start(self):
18         self.sock.connect(self.raddr)
19 
20         threading.Thread(target=self.recv, name='c-recv').start()
21 
22         #  每隔interval 就傳送一次心跳資訊
23         threading.Thread(target=self.hearbeat, name='ht',daemon=True).start()
24 
25     def recv(self):
26         while not self.event.is_set():
27             data, raddr = self.sock.recvfrom(1024)
28             print(data)
29             print(raddr)
30     def hearbeat(self):
31         while not self.event.wait(self.interval):
32             self.send('^hb^')
33 
34 
35 
36     def send(self, msg):
37         self.sock.send(msg.encode())
38 
39     def stop(self):
40         self.sock.close()
41         self.event.set()
42 
43 
44 def main():
45     cc = ChatClient()
46     cc.start()
47 
48     while True:
49         cmd = input('>>')
50         if cmd == 'quit':
51             cc.stop()
52             break
53         cc.send(cmd)
54         logging.info(threading.enumerate())
55 
56 
57 
58 if __name__ == "__main__":
59     main()

　　　　注意：

　　　　　　如果是如上圖所示，是一個直譯器程序，建立兩個物件，但是這兩個物件分別在不同的執行緒中跑。

　　　　　　如果直接執行兩次 client，就是兩個客戶端程序

UDP 協議的應用:

　　UDP 是無連線的，它是基於以下假設：

　　　　網路足夠好
　　　　訊息不會丟包

　　　　包不會亂序

　　但是，即使在區域網，也不能保證不丟包，而且包到達的不一定有序。

　　應用場景：

　　　　視訊，音訊傳輸，一般來說丟一些包。