Python网络编程：IO多路复用

io多路复用：可以监听多个文件描述符（socket对象）（文件句柄），一旦文件句柄出现变化，即可感知。

sk1 = socket.socket()
sk1.bind(('127.0.0.1',8001))
sk1.listen()

# sk2 = socket.socket()
# sk2.bind(('127.0.0.1',8002))
# sk2.listen()
while True:
    conn,address = sk.accept()#阻塞等待客户端连接、连接、客户端地址信息
    print(conn,address)
    conn.sendall(bytes('北京欢迎你',encoding='utf-8'))
    while True:
        ret_bytes = conn.recv(1024)
        ret_str = str(ret_bytes,encoding='utf-8')
        if ret_str == 'q':
            break
        conn.sendall(bytes(ret_str+'好',encoding='utf-8'))
    print(address,conn)

sk1sk2就叫作文件描述符、文件句柄。上面的程序只能执行sk1。

IO多路复用有一种机制，可以接受多个文件描述符，一旦有谁变化了，就处理。

import socket
sk1 = socket.socket()
sk1.bind(('127.0.0.1',8001))
sk1.listen()

sk2 = socket.socket()
sk2.bind(('127.0.0.1',8002))
sk2.listen()

sk3 = socket.socket()
sk3.bind(('127.0.0.1',8002))
sk3.listen()

inputs = [sk1,sk2]
#本例是用select伪装成多处理用户连接请求，比socket的好处在于不用等待？ 难点在于inputs里两类socket，客户端socket和服务端socket？
import select
while True:
    #[sk1,sk2,],select内部自动监听sk1,sk2，sk3三个对象，一旦某个句柄发生变化，就会将其放到r_list里。第一次发生变化是sk.accept()，即有人来连sk1.则r_list = [sk1]
    r_list,w_list,e_list = select.select(inputs,outputs,inputs,1)#等一秒看是否有人来连接，没有的话执行下一次循环。最多等待的时间。
    print('正在监听的socket对象%d' % len(inputs))
    print(r_list)
    for sk1_or_conn in r_list:

IO多路复用是操作系统底层提供的功能，我们只是用Python去调用它，分三种方式，select,poll,epoll。windows只支持select.

select底层实现原理：

系统内部c语言进行for循环检测，当文件句柄发送变化的时候告诉我们。性能较低，并且只支持最多1024个文件描述符。

所以后来就有了poll，对于文件描述符个数没限制了，但底层也是用for循环实现的。

之后又出现了epoll，底层就不用for循环了，而是用异步实现的，把句柄都放进去，谁有变化了谁主动告诉epoll，而不是for循环一遍遍监测。所以epoll的性能是最高的。

Nginx的内部就是socket结合epoll来监听用户请求的。

for sk in e_list:  #e_list是发生错误的文件描述符列表

    inputs.remove(sk)

import socket
sk1 = socket.socket()
sk1.bind(('127.0.0.1',8001))
sk1.listen()

# sk2 = socket.socket()
# sk2.bind(('127.0.0.1',8002))
# sk2.listen()
#
# sk3 = socket.socket()
# sk3.bind(('127.0.0.1',8003))
# sk3.listen()
inputs = [sk1]
outputs = []
#本例是用select伪装成多处理用户连接请求，比socket的好处在于不用等待？ 难点在于inputs里两类socket，客户端socket和服务端socket。
import select
while True:
    #[sk1,sk2,],select内部自动监听sk1,sk2,sk3三个对象，一旦某个句柄发生变化
    r_list,w_list,e_list = select.select(inputs,outputs,inputs,1)
    print('正在监听的socket对象%d' % len(inputs))
    print(r_list)
    for sk1_or_conn in r_list:
        #每一个连接对象
        if sk1_or_conn == sk1:
            #表示有新用户来连接
            conn, address = sk1_or_conn.accept()
            inputs.append(conn)
        else:
            #有老用户发消息了
            try:
                data_bytes = sk1_or_conn.recv(1024)
            except Exception as ex:
                #如果用户中断连接
                inputs.remove(sk1_or_conn)
            else:
                #用户正常发消息
                # data_str = str(data_bytes,encoding='utf-8')
                # sk1_or_conn.sendall(bytes(data_str+'好',encoding = 'utf-8'))
                outputs.append(sk1_or_conn)
#w_list仅仅存谁给我发过消息，如果想读写分离就会用到这个参数
    for conn in w_list:
        conn.sendall(bytes('hello',encoding='utf-8'))
        outputs.remove(conn)

上面的难点在于要理解r_list其实并不等于inputs.

inputs里面两类数据，一类是服务端的socket sk1，另一类是客户端的socket（只要有人来连接就apend一个socket对象）

而r_list里面存的是发生变化的对象，多个用户来连sk1，r_list里就是sk1，而有用户发消息，那r_list里就变为发消息的socket对象其。

socketserver：
select/epoll + socket +多线程实现并发操作。