Select， Poll，Epoll

Date: 2019-06-19

Author: Sun

1. Select

​ select最早于1983年出现在4.2BSD中，它通过一个select()系统调用来监视多个文件描述符的数组，当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位，使得进程可以获得这些文件描述符从而进行后续的读写操作。

​ select目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点，事实上从现在看来，这也是它所剩不多的优点之一。

​ select的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，不过可以通过修改宏定义甚至重新编译内核的方式提升这一限制。

​ 另外，select()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的开销也线性增长。同时，由于网络响应时间的延迟使得大量TCP连接处于非活跃状态，但调用select()会对所有socket进行一次线性扫描，所以这也浪费了一定的开销。

​ Select是一种线性扫描方式处理

​ 在python中，select函数是一个对底层操作系统的直接访问的接口。它用来监控sockets、files和pipes，等待IO完成（Waiting for I/O completion）。当有可读、可写或是异常事件产生时，select可以很容易的监控到。

​ select.select（rlist, wlist, xlist[, timeout]） 传递三个参数，一个为输入而观察的文件对象列表，一个为输出而观察的文件对象列表和一个观察错误异常的文件列表。第四个是一个可选参数，表示超时秒数。其返回3个tuple，每个tuple都是一个准备好的对象列表，它和前边的参数是一样的顺序。

2. Poll

poll在1986年诞生于System V Release 3，它和select在本质上没有多大差别，但是poll没有最大文件描述符数量的限制。

poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。

另外，select()和poll()将就绪的文件描述符告诉进程后，如果进程没有对其进行IO操作，那么下次调用select()和poll()的时候将再次报告这些文件描述符，所以它们一般不会丢失就绪的消息，这种方式称为水平触发（Level Triggered）。

3. 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

​ 在python中，select函数是一个对底层操作系统的直接访问的接口。它用来监控sockets、files和pipes，等待IO完成（Waiting for I/O completion）。当有可读、可写或是异常事件产生时，select可以很容易的监控到。

select.select（rlist, wlist, xlist[, timeout]） 传递三个参数，一个为输入而观察的文件对象列表，一个为输出而观察的文件对象列表和一个观察错误异常的文件列表。第四个是一个可选参数，表示超时秒数。其返回3个tuple，每个tuple都是一个准备好的对象列表，它和前边的参数是一样的顺序。

当我们调用select()时：

　　1、上下文切换转换为内核态

　　2、将fd从用户空间复制到内核空间

　　3、内核遍历所有fd，查看其对应事件是否发生

　　4、如果没发生，将进程阻塞，当设备驱动产生中断或者timeout时间后，将进程唤醒，再次进行遍历

　　5、返回遍历后的fd

　　6、将fd从内核空间复制到用户空间

通过socket建立网络连接的步骤:
   至少需要2个套接字, server和client
   需要建立socket之间的连接, 通过连接来进行收发data

client 和 server连接的过程:
  1. 建立server的套接字,绑定主机和端口,并监听client的连接请求
  2. client套接字根据server的地址发出连接请求, 连接到server的socket上; client socket需要提供自己的 socket fd,以便server socket回应
  3. 当server监听到client连接请求时, 响应请求, 建立一个新的线程, 把server fd 发送给client

而后, server继续监听其他client请求, 而client和server通过socket连接互发data通信

select方法

fd_r_list, fd_w_list, fd_e_list ``= select.select(rlist, wlist, xlist, [timeout])

参数： 可接受四个参数（前三个必须）

• rlist: wait until ready for reading
• wlist: wait until ready for writing
• xlist: wait for an “exceptional condition”
• timeout: 超时时间

返回值：三个列表

fd_r_list： 读列表， fd_w_list：写列表， fd_e_list ：异常列表

4. 案例分析

服务器端代码：

import socket, select, threading

host = socket.gethostname()
port = 5963
addr = (host, port)

inputs = []
fd_name = {}
def who_in_room(w):
    name_list = []
    for k in w:
        name_list.append(w[k])
    return name_list

def conn():
    print('wait connecting...')
    ss = socket.socket()
    ss.bind(addr)
    ss.listen(5)
    return ss

def new_coming(ss):
    client, add = ss.accept()
    print('欢迎 %s %s' % (client, add))
    wel = '''聊天室，请输入您的名称:'''
    try:
        client.send(wel.encode(encoding='utf8'))
        name = client.recv(1024).decode(encoding='utf8')
        inputs.append(client)
        fd_name[client] = name
        nameList = "当前聊天室内，有如下成员： %s" % (who_in_room(fd_name))
        client.send(nameList.encode(encoding='utf8'))
    except Exception as e:
        print(e)

def server_run():
    ss = conn()
    inputs.append(ss)

    while True:
        rList, wList, eList = select.select(inputs, [], [])
        for temp in rList:
            if temp is ss:
                new_coming(ss)
            else:
                disconnect = False
                try:
                    data = temp.recv(1024)    #bytes
                    data = data.decode(encoding='utf8')   #str
                    user_name = fd_name[temp]    #bytes
                    data = user_name + ' say : ' + data
                    #data = data.decode('utf8')
                except socket.error:
                    data = fd_name[temp] + ' leave the room'
                    disconnect = True
                if disconnect:
                    inputs.remove(temp)
                    print(f"disconnect message:{data}")
                    for other in inputs:
                        if other != ss and other != temp:
                            try:
                                other.send(data.encode(encoding='utf8'))
                            except Exception as e:
                                print(e)
                    del fd_name[temp]

                else:
                    print(f"connect message: {data}")
                    for other in inputs:
                        if other != ss and other != temp:
                            try:
                                other.send(data.encode(encoding='utf8'))
                            except Exception as  e:
                                print(e)

if __name__ == '__main__':
    server_run()

客户端代码：

# -*- coding: utf-8 -*-
__author__ = 'sun'
__date__ = '2019/6/19 15:18'

import socket, select, threading, sys;

host = socket.gethostname()

addr = (host, 5963)

def conn():
    s = socket.socket()
    s.connect(addr)
    return s

def lis(s):
    my = [s]
    while True:
        r, w, e = select.select(my, [], [])
        if s in r:
            try:
                print(s.recv(1024).decode(encoding='utf8'))
            except socket.error:
                print('socket is error')
                exit()

def talk(s):
    while True:
        try:
            info = input('')
            s.send(info.encode(encoding='utf8'))
        except Exception as  e:
            print(e)
            exit()

def main():
    ss = conn()
    t = threading.Thread(target=lis, args=(ss,))
    t.start()
    t1 = threading.Thread(target=talk, args=(ss,))
    t1.start()

if __name__ == '__main__':
    main()

启动一个服务器端代码，启动两个客户端代码；两个客户端进行通信，中间经过服务器进行中转。

扩展：考虑采用python配色方案来处理上述网络场景。