python模擬地面網管接收數據

鏈接：https://pan.baidu.com/s/1_BvoHPaUZXEnTqTNBcviNw
提取碼：edg0
複製這段內容後打開百度網盤手機App，操作更方便哦

# -*- coding: utf-8 -*
import socket
import threading
import SocketServer

import Queue
import time

queue_list = {}
client_list = []
socketdatalist = {}
#線程句柄，處理每個線程內收到的監控板數據
class ThreadedUDPRequestHandler(SocketServer.BaseRequestHandler):

    def handle(self):
        data = self.request[0]
        socket = self.request[1]
        #打印收到的監控板的ip和端口號
        print "\r\n 服務器已連接 from: ", self.client_address[0],"\t port:",self.client_address[1]
        #print "\r\n 服務器已連接 接收數據爲: ", data
        #釋放系統資源
        del socket
        del data

#該類會啓動線程句柄
class TYThreadingMixIn:
    """Mix-in class to handle each request in a new thread."""

    # Decides how threads will act upon termination of the
    # main process
    daemon_threads = False

    def process_request_thread(self,queue, client_address):
        """Same as in BaseServer but as a thread.

        In addition, exception handling is done here.

        """
        while True:
            try:
            #隊列爲阻塞型，如果沒有數據則線程處理暫停
                task = queue.get(block=True,timeout=10)
            except Queue.Empty:
                cur_thread = threading.current_thread()
                log="Thread:name{} NO.{} client {} queue timeout over!".format(cur_thread.name, cur_thread.ident, client_address)
                client_name = ("{}_{}".format(client_address[0], client_address[1]))
                client_list.remove(client_name)
                queue_list.pop(client_name)
                print log
                break
            #print task
            queue.task_done()

            try:
                self.finish_request(task, client_address)
                self.shutdown_request(task)
            except:
                self.handle_error(task, client_address)
                self.shutdown_request(task)

    #啓動一個新的線程，處理每個新增加的監控板地址
    def process_request(self, request, client_address):
        """Start a new thread to process the request."""
        client_name = ("{}_{}".format(client_address[0], client_address[1]))
        #如果監控板的ip沒有在list中，則在隊列中新增一條監控板地址信息
        if client_name not in client_list:
            client_list.append(client_name)
            queue_list[client_name] = Queue.Queue(100)
            #啓動一個線程，進行超時處理，如果10秒鐘未接受到監控板的數據，則刪除該監控板線程
            t = threading.Thread(target = self.process_request_thread,
                                 args = (queue_list[client_name], client_address),
                                 name=client_name)
            t.daemon = self.daemon_threads

            t.start()
        #在隊列中假如新的監控板地址信息
        queue_list[client_name].put(request)

def client(ip, port, message, name, cycle=0):
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    #sock.connect((ip, port))
    try:
        for i in range(0,cycle):
            sock.sendto("{} cnt {}".format(message,i),(ip, port))
            response = sock.recvfrom(65536)
            print "Client{}:get: {}".format(name,response)
    finally:
        sock.close()

class TYThreadingUDPServer(TYThreadingMixIn, SocketServer.UDPServer): pass

#主函數
if __name__ == "__main__":
    #綁定ip和端口，目前設定爲綁定所有ip的11111端口
    HOST, PORT = "0.0.0.0", 11111

    server = TYThreadingUDPServer((HOST, PORT), ThreadedUDPRequestHandler)
    ip, port = server.server_address

    # 啓動一個socket線程池
    server_thread = threading.Thread(target=server.serve_forever)
    # Exit the server thread when the main thread terminates
    server_thread.daemon = True
    server_thread.start()
    print "Server loop running in thread:", server_thread.name
    server_thread.join()

    #進程等待，該主進程等待所有的線程結束
    while True:
        time.sleep(5)
        try:
            i=1
            #for k,v in queue_list.iteritems():
            #    print i,":",k
            #    i=i+1
        except:
            server.shutdown()
            server.server_close()

        finally:
            pass

    #釋放系統資源
    server.shutdown()
    server.server_close()