socketserver 和 事件Event

socketserver
    处理socket服务端
        # 服务端TCP：
        import socketserver
        from threading import current_thread
        # fork linux 下一个进程接口 windows没有这接口

        # 用于处理请求的类
        class MyHandler(socketserver.BaseRequestHandler):
            def handle(self):
                print(self)
                print(self.server) # 获取封装的服务器对象
                print(self.client_address) # 客户端地址
                print(self.request) # 获取客户端的socket对象
                print(current_thread())
                while True:
                    data = self.request.recv(1024)
                    print(data.decode("utf-8"))
                    self.request.send(data.upper())
        server=socketserver.ThreadingTCPServer(("127.0.0.1",9014),MyHandler,True)# 是否绑定 默认为True
        server.serve_forever()

        #客户端TCP：
            import socket
            client=socket.socket()
            client.connect(("127.0.0.1",9014))
            while True:
                data=input(">>:")
                client.send(data.encode("utf-8"))
                dic=client.recv(1034)
                print(dic.decode("utf-8"))

        # 服务端UDP：
            import socketserver
            from threading import current_thread
            # fork linux 下一个进程接口 windows没有这接口

            # 用于处理请求的类
            class MyHandler(socketserver.BaseRequestHandler):
                def handle(self):
                    print(self)
                    print(self.server) # 获取封装的服务器对象
                    print(self.client_address) # 客户端地址
                    print(self.request) # 获取客户端的socket对象,在udp中会自动获取客户端数据+客户端对象
                    print(current_thread())
                    while True:
                        data = self.request[0]
                        print(data.decode("utf-8"))
                        self.request[1].sendto(data.upper(),self.client_address)
                        break
            server=socketserver.ThreadingUDPServer(("127.0.0.1",9014),MyHandler,True)# 是否绑定 默认为True
            server.serve_forever()

        客户端UDP：
            import socket
            client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
            # client.connect()
            addr=("127.0.0.1",9014)
            while True:
                data=input(">>:")
                client.sendto(data.encode("utf-8"),addr)
                dic=client.recvfrom(1024)[0]
                print(dic.decode("utf-8"))

    #ThreadingUDPServer 在初始化的时候创建了socket对象
    #serve_forever() 将socket注册到select（多路复用）
    #select中返回一个ready 如果为True则可以处理 _handle_request_noblock 内部创建了MyHandler

    #使用了socket OOP 多线程
    #在正常开发中

    #使用时的区别：
        #ThreadingTCPServer
            #handle 在连接成功时执行
            #self.request 是客户端的socket对象

        #ThreadingUDPServer
            #handle 接受到数据执行时执行
            #self.request 数据和服务器端的socket对象

Event  多线程知识点
    事件是什么？ 某件事情发生的信号
    用来做什么？ 在线程间通讯 然而线程间本来就可以相互通讯
                 作用就只剩下简化代码了

    线程间通讯的例子
    服务器启动需要五秒
    客户端启动后连接服务器
    去连接服务器必须保证服务器已经开启成功了

    是否启动完成就是要通讯的内容

    注意 Event线程通讯 仅仅用于简单的条件判断 说白就是代替bool类型 和if判断类似
    set() 将状态修改为True
    wati() 等待状态为True才能继续执行

    举例：
    实现相同效果的代码对比：
        import time
        from threading import Thread,Event #事件
        event=Event()
        # boot=False
        def server_task():
            global boot
            print("正在启动....")
            time.sleep(5)
            print("启动...成功")
            event.set()
            # boot=True

        def client_task():
            event.wait() # 一个阻塞的函数 会阻塞直到对evernt执行set函数为止
            print("连接成功")
            # while True:
            #     time.sleep(1)
            #     print("连接服务器")
            #     if boot:
            #         print("连接成功")
            #         break
            #     else:
            #         print("连接失败，服务器没有启动")

        t1=Thread(target=server_task)
        t2=Thread(target=client_task)
        t1.start()
        t2.start()
        # t1.join()
        # t2.join()