python开发之路之I/O多路复用

前言

　　1.什么是I/O多路复用？

　　　　

　　我们都知道，在同一时刻，我们的服务器端只能处理同1个客户端，即客户端和服务器端处于一对一的模式。即服务器端和客户端在进行请求、响应都是1对1的进行。

　　但是，现在的需求是：我们要让多个客户端连接至服务器端，而且服务器端需要处理来自多个客户端请求，这样的话，传统的模式就实现不了了，此时我们该采用什么方式来处理呢？

　　解决方法：

　　　　　采用I/O多路复用机制。在python网络编程中，I/O多路复用机制就是用来解决多个客户端连接请求服务器端，而服务器端能正常处理并响应给客户端的一种机制。

　　　　　书面上来说，就是通过1种机制：可以监听多个文件描述符，一旦描述符就绪，能够通知程序进行相应的读写操作。

　　2.什么是文件描述符？

　　　　在网络中，一个socket对象就是1个文件描述符，在文件中，1个文件句柄（即file对象）就是1个文件描述符。其实可以理解为就是一个“指针”或“句柄”，指向1个socket或file对象，当file或socket发生改变时，这个对象对应的文件描述符，也会发生相应改变。

　　3.在python中I/O操作包括哪些?

• 网络操作，即建立socket对象，进行建立连接，发送、接收、处理请求、响应等
• 文件操作，即建立file对象，进行文件的读、写操作
• 终端操作。即进行交互式输入输出等操作

　　4.I/O多路复用

　　　在I/O编程过程中，当需要同时处理多个客户端接入请求时，可以利用多线程或者I/O多路复用技术进行处理。

　　　I/O多路复用技术通过把多个I/O的阻塞复用到同一个select的阻塞上，从而使得系统在单线程的情况下可以同时处理多个客户端请求。

　　　与传统的多线程/多进程模型比，I/O多路复用的最大优势是系统开销小，系统不需要创建新的额外进程或者线程，也不需要维护这些进程和线程的运行，降底了系统的维护工作量，节省了系统资源。

　　5.I/O多路复用的主要应用场景如下：

• 服务器需要同时处理多个处于监听状态或者多个连接状态的套接字。

• 服务器需要同时处理多种网络协议的套接字。

一、python的select模块应用

　　在Python中有一个select模块，其中提供了：select、poll、epoll三个方法，分别调用系统的 select，poll，epoll ，从而实现IO多路复用。

　　在Linux中，I/O多路复用具体介绍如下所示：

select   select最早于1983年出现在4.2BSD中，它通过一个select()系统调用来监视多个文件描述符的数组，当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位，使得进程可以获得这些文件描述符从而进行后续的读写操作。 select目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点，事实上从现在看来，这也是它所剩不多的优点之一。 select的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，不过可以通过修改宏定义甚至重新编译内核的方式提升这一限制。 另外，select()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的开销也线性增长。同时，由于网络响应时间的延迟使得大量TCP连接处于非活跃状态，但调用select()会对所有socket进行一次线性扫描，所以这也浪费了一定的开销。   poll   poll在1986年诞生于System V Release 3，它和select在本质上没有多大差别，但是poll没有最大文件描述符数量的限制。 poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。 另外，select()和poll()将就绪的文件描述符告诉进程后，如果进程没有对其进行IO操作，那么下次调用select()和poll()的时候将再次报告这些文件描述符，所以它们一般不会丢失就绪的消息，这种方式称为水平触发（Level Triggered）。   epoll   直到Linux2.6才出现了由内核直接支持的实现方法，那就是epoll，它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。 epoll可以同时支持水平触发和边缘触发（Edge Triggered，只告诉进程哪些文件描述符刚刚变为就绪状态，它只说一遍，如果我们没有采取行动，那么它将不会再次告知，这种方式称为边缘触发），理论上边缘触发的性能要更高一些，但是代码实现相当复杂。 epoll同样只告知那些就绪的文件描述符，而且当我们调用epoll_wait()获得就绪文件描述符时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可，这里也使用了内存映射（mmap）技术，这样便彻底省掉了这些文件描述符在系统调用时复制的开销。 另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而epoll事先通过epoll_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。

 　　select方法，用来监视文件句柄，如果句柄发生变化，则获取该句柄

　　　　select(rlist, wlist, xlist[, timeout]) -> (rlist, wlist, xlist)

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

　　　　参数： 可接受四个参数（前三个必须），rlist, wlist, xlist[, timeout]
　　　　返回值：三个列表：rlist, wlist, xlist

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

　　示例1，linux下监视终端操作的实例，即把输入的东西读出来。（在linux环境下使用该示例）

• 其实我们输入的东西，在linux下是放在sys模块下的stdin管道里面的，系统要使用的时候是在stdin里面读、取的。
• 读取输入管道里面的东西，采用：sys.stdin.readline()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import select
import threading
import sys

while True:
　　#监听select的第一个参数：sys.stdin，这里表示监听用户输入，我们的sys.stdin相当于终端描述符，相当于文件的句柄。
　　#如果监听到有更改，即用户有输入，select就会感知到，然后就把变化的文件句柄保存至列表，并将列表返回给第一个参数：readable
　　#如果没有改变，即用户没有输入，select就会感知到没有改变，readable列表就是空的列表[]
    readable,writeable,error = select.select([sys.stdin,],[],[],1)
    if sys.stdin in readable:
        print "select get stdin",sys.stdin.readline()

　　示例2：监听多个I/O（这里指socket对象），用浏览器访问，并打印访问的客户端地址

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket
import select

sk = socket.socket()
ip_port = ('127.0.0.1',8888)
sk.bind(ip_port)
sk.listen(5)
#设置不阻塞
sk.setblocking(False)

sk1 = socket.socket()
ip_port1 = ('127.0.0.1',9999)
sk1.bind(ip_port1)
sk1.listen(5)
#设置不阻塞，即后面的accept会自动阻塞，使用setblocking(False)就不会自动阻塞了。
sk1.setblocking(False)

#设置要监听的句柄，放在列表内
inputs = [sk,sk1,]
#当客户端连接上服务器端时，服务端的sk就发生变化了，此时就会被select监听到。

while True:
    rList,w,e = select.select(inputs,[],[],2)
    for r in rList:
        conn,addr = r.accept()
　　　　#conn表示得到的客户端的socket句柄
        print addr  #打印来访问的客户端的IP和端口
sk.close()

　　

在浏览器中打开2个窗口，分别输入127.0.0.1:8888和127.0.0.1:8888，访问结果显示如下：

示例3：监听多个客户端来发数据。代替多线程、多进程，使用select处理多个请求。

server.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket
import select

sk = socket.socket()
ip_port = ('127.0.0.1',8888)
sk.bind(ip_port)
sk.listen(5)
#设置不阻塞
sk.setblocking(False)

inputs = [sk,]
##sk跟客户端连接有关
##conn跟客户端发收数据有关
while True:
　　#inputs表示要监听的句柄的序列，一旦此句柄发生变化，rList就会获取到
    rList,w,e = select.select(inputs,[],[],2)
    print "rList",rList
    print "inputs",inputs
    for r in rList:
        #如果变化的是服务器端，表示有新的连接进入.
        # 即当客户端第一次连接上服务器端
        if r == sk:
            conn,addr = r.accept()
            #将新连接的客户端加入监听列表inputs内
            inputs.append(conn)
            print addr
        else:
        #否则，变化的是客户端，就进行接收数据.然后发送数据
        #当客户端进行收发数据时
            client_data = r.recv(1024)
            #将发来的数据返回给客户端
            r.sendall(client_data)

sk.close()　　

client.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket

sk = socket.socket()
ip_port = ('127.0.0.1',8888)
sk.connect(ip_port)

while True:
    inp = raw_input("plz input:")
    sk.sendall(inp)
    get_data = sk.recv(1024)
    print get_data
sk.close()

先启动服务端，即执行server.py,进行监听。然后，再启动第1个客户端，即执行client.py进行连接。然后再启动第2个客户端，即再执行client.py进行连接。我们在客户端的显示结果中可以看到监听--连接过程中，rList和inputs发生的变化如下图所示：

注意：tornado的源码就是用的select中的select机制

　　示例4：试想：如果客户端的数据断开了，我们该如何将此前添加的断开的客户端的套接字从inputs中移除呢？

　　其实如果客户端断开与服务器端的连接，客户端会向服务器端发送1个空的消息。通过空的消息我们就可以做个判断，如果服务端得到的是空的数据，我们在inputs列表里面将客户端去掉就可以了。具体服务器端的代码更改如下：

server.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket
import select

sk = socket.socket()
ip_port = ('127.0.0.1',8888)
sk.bind(ip_port)
sk.listen(5)
#设置不阻塞
sk.setblocking(False)

inputs = [sk,]
##sk跟客户端连接有关
##conn跟客户端发收数据有关
output = []
while True:
    #w，如果select第二个参数,只要不是空列表，select就会感知到并赋值给w
    #e,如果select在进行监听句柄时出问题了，我们就会将错误存放在e中
    #select函数中的第4个参数:2，表示只在select这里阻塞2s，2s之后没连接，就继续执行下面的流程。
    rList,w,e = select.select(inputs,output,[],2)
    print "rList",rList
    print "inputs",inputs
    #print "output:",output
    import time
    time.sleep(2)
    for r in rList:
        #如果变化的是服务器端，表示有新的连接进入.
        # 即当客户端第一次连接上服务器端
        if r == sk:
            conn,addr = r.accept()
            #将新连接的客户端加入监听列表inputs内
            inputs.append(conn)
            output.append(conn)
            print addr
        else:
        #否则，变化的是客户端，就进行接收数据.然后发送数据
        #当客户端进行收发数据时
            client_data = r.recv(1024)
            #将发来的数据返回给客户端
            #如果收到的客户端数据不是空的
            if client_data:
                r.sendall(client_data)
            #否则，收到的客户端数据时空的，即客户端已经断开连接了，就在inputs列表中去掉r就可以了
            else:
                inputs.remove(r)

sk.close()

　　

 　　示例5：select进行读写拆分.

现在要创建1种效果，遵循select的规范，
　　只要文件描述符可读，我们就让rList感知，只有变化的时候才可以感知。rList只读，从读取数据
　　如果文件描述符可写，我们就让wList感知。wList可写，即进行写数据
即把读和写拆开。

所以server端的server.py的代码如下：

server.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket
import select
import Queue

sk = socket.socket()
ip_port = ('127.0.0.1',8888)
sk.bind(ip_port)
sk.listen(5)
#设置不阻塞
sk.setblocking(False)

inputs = [sk,]
##sk跟客户端连接有关
##conn跟客户端发收数据有关
output = []
message = {}

while True:
    #wList，如果select第二个参数,只要不是空列表，select就会感知到并赋值给w
    #e,如果select在进行监听句柄时出问题了，我们就会将错误存放在e中
    #select函数中的第4个参数:2，表示只在select这里阻塞2s，2s之后没连接，就继续执行下面的流程。
    rList,wList,e = select.select(inputs,output,[],2)
    print "rList",rList
    print "inputs",inputs
    #print "output:",output
    import time
    time.sleep(2)
    for r in rList:
        #如果变化的是服务器端，表示有新的连接进入.
        # 即当客户端第一次连接上服务器端
        if r == sk:
            conn,addr = r.accept()
            #将新连接的客户端加入监听列表inputs内
            inputs.append(conn)
            #创建1个队列
            message[conn] = Queue.Queue()
        else:
        #否则，变化的是客户端，就进行接收数据.然后发送数据
        #当客户端进行收发数据时
            client_data = r.recv(1024)
            if client_data:
                #获取数据
                output.append(r)
                #在指定队列中插入数据
                message[r].put(client_data)
            else:
                #如果客户端断开连接的话，就从inputs中移除
                inputs.remove(r)

    for w in wList:
        #去指定队列取数据，取完数据然后再发
        try:
            data = message[w].get_nowait()
            w.sendall(data)
        except Queue.Empty:
            pass
        output.remove(w)
        del message[w]

sk.close()