基于UDP的交互的实例

1.实现简单的客户端、服务端聊天交互

　　问题是：客户端不能单独一直发消息回复、、

服务端：
import socket
server=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
server.bind(('127.0.0.1',8080))

while True:
    client_data,client_addr=server.recvfrom(1024)
    print(client_data.decode(),client_addr)
    while True:
        msg=input('回复给Client%s的消息>>>:'%client_addr[0])
        # server.sendto(msg.encode('utf-8'),('127.0.0.1',8080))
        # 特别注意：这里回复消息是一定要写client_addr不能固定
        #是针对上面recvfrom收到的客户端接口定向发送的，这个接口不能写死，每个交互的客户端接口都是不一样的
        server.sendto(msg.encode('utf-8'),client_addr)
        print(client_addr)

客户端：
import socket
client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

while True:
    msg=input('>>>:')
    client.sendto(msg.encode('utf-8'),('127.0.0.1',8080))
    while True:
        server_data,server_addr=client.recvfrom(1024)
        print(server_data.decode())            

 

 

2.socketserver实现并发通信

socketserver-TCP应用实例：
并发：看起来同时运行，连接数少的时候并没有感觉，连接数多的时候，就会有延迟
原理就是：
将通信循环放到类里面，通过实例化对象将数据+方法整合到一起
s=socketserver.ThreadingTCPServer((服务端的IP和端口),类名,bind_and_activate=True就是bind和listen)
s:相当与是一个负责连接的套接字对象；
self.request

s=socketserver.ThreadingTCPServer(('127.0.0.1',8080),Myhandler,bind_and_activate=True)

ThreadingTCPServer：线程，没成功建立一个连接，就会启动一个线程（服务员）
负责专门与建立好的连接做通信循环（调用Myhandler类下面的handle函数）

如何配置：

服务端配置：
import socketserver

class Myhandler(socketserver.BaseRequestHandler):
    def handle(self):
        while True:                              #循环的去通信
            try:
                data=self.request.recv(1024)      #收消息
                if len(data) == 0:break
                self.request.send(data.upper())   #发消息 #self.request=conn
            except ConnectionResetError:
                break
        self.request.close()

if __name__ == '__main__':
    s=socketserver.ThreadingTCPServer(('127.0.0.1',8080),Myhandler,bind_and_activate=True)
    s.serve_forever()   #循环建立连接

--------------------------------------------------------------------------------

客户端配置无需进行改动。。
import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect(('127.0.0.1',8080))
while True:
    msg=input('输入发送的内容：')
    if len(msg) == 0:continue
    phone.send(msg.encode('utf-8'))
    data=phone.recv(1024)
    print(data.decode('utf-8'))

phone.close()

 

socketserver-UDP应用实例：

服务端配置：

import socketserver

class Myhandler(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.client_address)  #('127.0.0.1', 49228)  元组格式
        print(self.request)  #一个元祖：1：数据 2：套接字对象 #(b'\xe4\xbd\xa0\xe5\xa5\xbd', <socket.socket fd=528...>)
        # self.request:相当与收到了一个报头（数据部分，套接字对象）

        data = self.request[0]  #元组的第一位就是数据，第二位是套接字对象

        print('客户消息：',data.decode('utf-8'))
        self.request[1].sendto(data.upper(),self.client_address)


if __name__ == '__main__':
    s = socketserver.ThreadingUDPServer(('127.0.0.1', 8080), Myhandler, bind_and_activate=True)
    s.serve_forever()


---------------------------------------------------------------------------
客户端配置：
import socket

client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
while True:
    msg=input('>>>:').strip()
    client.sendto(msg.encode('utf-8'),('127.0.0.1',8080))
    data,server_addr=client.recvfrom(1024)
    print(data.decode('utf-8'))

client.close()

 

知识点四：
1.串行：一个任务完完整整的运行完毕后，才能运行下一个任务

2.并发：看起来多个任务是同时运行的即可，单核也可以实现并发

3.并行：真正意义上多个任务的同时运行，只有多核才实现并行

4.cpu功能:cup是用来做计算，cpu是无法执行IO操作的，一旦遇到io操作，应该让cpu去执行别的操作

5.多道技术：
1.空间上的复用=》多个进程公用一个内存，如内存中同时有多道程序
2.时间上的复用=》多个进程复用同一个cpu的时间，复用一个cpu的时间片
cpu遇到IO切换：可以提升效率
强调：遇到io切，占用cpu时间过长也切，核心在于切之前将进程的状态保存下来，这样
才能保证下次切换回来时，能基于上次切走的位置继续运行