python16_day09【Select多路复用】

一、select多路复用

 句柄列表11, 句柄列表22, 句柄列表33 = select.select(句柄序列1, 句柄序列2, 句柄序列3, 超时时间)

 参数： 可接受四个参数（前三个必须）
 返回值：三个列表

 select方法用来监视文件句柄，如果句柄发生变化，则获取该句柄。
 1、当 参数1 序列中的句柄发生可读时（accetp和read），则获取发生变化的句柄并添加到 返回值1 序列中
 2、当 参数2 序列中含有句柄时，则将该序列中所有的句柄添加到 返回值2 序列中
 3、当 参数3 序列中的句柄发生错误时，则将该发生错误的句柄添加到 返回值3 序列中
 4、当 超时时间 未设置，则select会一直阻塞，直到监听的句柄发生变化
    当 超时时间 ＝ 1时，那么如果监听的句柄均无任何变化，则select会阻塞 1 秒，之后返回三个空列表，如果监听的句柄有变化，则直接执行。

 import select
 import socket

 sk1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 sk1.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 sk1.bind(('127.0.0.1', 8001),)
 sk1.listen(5)

 sk2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 sk2.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 sk2.bind(('127.0.0.1', 8002),)
 sk2.listen(5)

 inputs = [sk1, sk2]
 w_inputs = []
 while True:
     # IO多路复用,同时监听多个SOCKET对象.
     r, w, e = select.select(inputs, w_inputs, inputs, 0.05)  #

     for obj in r:
         print("obj::::", obj)
         print("sk1::::", sk1)
         if obj in [sk1, sk2]:
             # 新连接
             print("新连接....", obj)
             conn, addr = obj.accept()
             inputs.append(conn)
         else:
             # 有连接用户发送消息来了...
             print("有用户发数据了", obj)
             try:
                 data = obj.recv(1024)
             except Exception as e:
                 data = ""
             if data:
                 w_inputs.append(obj)
                 # obj.sendall(data)
             else:
                 obj.close()
                 inputs.remove(obj)
                 w_inputs.remove(obj)

     for obj in w_inputs:
         obj.sendall(b'ok')
         w_inputs.remove(obj)

利用select实现伪同时处理多个Socket客户端请求：服务端

 import socket

 client = socket.socket()

 client.connect(('127.0.0.1', 8001))

 while True:
     v = input(">>>>")
     if v == 'exit':
         break
     client.sendall(bytes(v, encoding='utf8'))
     ret = client.recv(1024)
     print("server respone:", ret)

 client.close()

利用select实现伪同时处理多个Socket客户端请求：客户端

二、socketserver模块

　　SocketServer内部使用 IO多路复用 以及 “多线程” 和 “多进程” ，从而实现并发处理多个客户端请求的Socket服务端。

　　即：每个客户端请求连接到服务器时，Socket服务端都会在服务器是创建一个“线程”或者“进程” 专门负责处理当前客户端的所有请求。

　　

　　1.ThreadingTCPServer

　　ThreadingTCPServer实现的Soket服务器内部会为每个client创建一个 “线程”，该线程用来和客户端进行交互。

　　使用ThreadingTCPServer:

• 创建一个继承自 SocketServer.BaseRequestHandler 的类
• 类中必须定义一个名称为 handle 的方法
• 启动ThreadingTCPServer

 import SocketServer

 class MyServer(SocketServer.BaseRequestHandler):

     def handle(self):
         # print self.request,self.client_address,self.server
         conn = self.request
         conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')
         Flag = True
         while Flag:
             data = conn.recv(1024)
             if data == 'exit':
                 Flag = False
             elif data == '':
                 conn.sendall('通过可能会被录音.balabala一大推')
             else:
                 conn.sendall('请重新输入.')

 if __name__ == '__main__':
     server = SocketServer.ThreadingTCPServer(('127.0.0.1',8009),MyServer)
     server.serve_forever()

secketserver服务端

 import socket

 ip_port = ('127.0.0.1',8009)
 sk = socket.socket()
 sk.connect(ip_port)
 sk.settimeout(5)

 while True:
     data = sk.recv(1024)
     print 'receive:',data
     inp = raw_input('please input:')
     sk.sendall(inp)
     if inp == 'exit':
         break

 sk.close()

socketserver客户端

　　2.源码剖析

　　

内部调用流程为：

• 启动服务端程序
• 执行 TCPServer.__init__ 方法，创建服务端Socket对象并绑定 IP 和 端口
• 执行 BaseServer.__init__ 方法，将自定义的继承自SocketServer.BaseRequestHandler 的类 MyRequestHandle赋值给 self.RequestHandlerClass
• 执行 BaseServer.server_forever 方法，While 循环一直监听是否有客户端请求到达 ...
• 当客户端连接到达服务器
• 执行 ThreadingMixIn.process_request 方法，创建一个 “线程” 用来处理请求
• 执行 ThreadingMixIn.process_request_thread 方法
• 执行 BaseServer.finish_request 方法，执行 self.RequestHandlerClass()  即：执行 自定义 MyRequestHandler 的构造方法（自动调用基类BaseRequestHandler的构造方法，在该构造方法中又会调用 MyRequestHandler的handle方法）

 import socket
 import threading
 import select

 def process(request, client_address):
     print request,client_address
     conn = request
     conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')
     flag = True
     while flag:
         data = conn.recv(1024)
         if data == 'exit':
             flag = False
         elif data == '':
             conn.sendall('通过可能会被录音.balabala一大推')
         else:
             conn.sendall('请重新输入.')

 sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 sk.bind(('127.0.0.1',8002))
 sk.listen(5)

 while True:
     r, w, e = select.select([sk,],[],[],1)
     print 'looping'
     if sk in r:
         print 'get request'
         request, client_address = sk.accept()
         t = threading.Thread(target=process, args=(request, client_address))
         t.daemon = False
         t.start()

 sk.close()

精简版sockserver

如精简代码可以看出，SocketServer的ThreadingTCPServer之所以可以同时处理请求得益于 select 和 Threading 两个东西，其实本质上就是在服务器端为每一个客户端创建一个线程，当前线程用来处理对应客户端的请求，所以，可以支持同时n个客户端链接（长连接）。