PythonIO多路复用

最新推荐文章于 2022-10-18 14:08:08 发布

油炸板蓝根

最新推荐文章于 2022-10-18 14:08:08 发布

阅读量469

点赞数

python IO 多路复用 select poll epoll

select

select原理

select是通过系统调用来监视着一个由多个文件描述符组成的数组，当select()返回后，数组中就绪的文件描述符会被内核修改标记位，使得进程可以获得这些文件描述符从而进行后续的读写操作。select是通过遍历来监视整个数组的，而且每次遍历都是线性的。

select优点

select目前几乎在所有的平台上支持，良好的跨平台性。

select缺点

每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多的时候会很大。
单个进程能够监视的fd数量存在最大限制，在linux上默认为1024（可以通过修改宏定义或者重新编译内核的方式提升这个限制）
并且由于select的fd是放在数组中，并且每次都要线性遍历整个数组，当fd很多的时候，开销也很大。

python select

调用select的函数为r,w,e = select.select(rlist,wlist,xlist[, timeout]),前三个参数都分别是三个列表，数组中的对象均为waitable object：均是整数的文件描述符（file descriptor）或者一个拥有返回文件描述符方法fileno()的对象：

rlist：等待读就绪的list
wlist：等待写就绪的list
errlist：等待“异常”的list

select方法用来监视文件描述符，如果文件描述符发生变化，则获取该描述符。

这三个list可以是一个空的list，但是接收3个空的list是依赖于系统的（在linux上是可以接受的，在windows上不可以）
当rlist序列中的描述符发生可读时（accept和read）

服务器代码

import select
import socket
from queue import Queue

from time import sleep

server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.setblocking(False)

server_address = ("localhost",8090)
print("starting up on %s port %s" % server_address)

server.bind(server_address)

server.listen(5)
inputs = [server]
outputs = []
message_queues= {}

while inputs:
    print("waiting for the next event.")

    readable,writable,exceptional = select.select(inputs, outputs, inputs)
    # 循环判断是否由客户端连接进来，当有客户端连接进来时select将触发
    for s in readable:
        # 判断当前触发的是不是服务端对象，当触发的对象服务端对象，说明有新客户端连接上来了
        # 表示有新用户连接
        if s is server:
            connection,client_address = s.accept()
            print("connection from",client_address)
            connection.setblocking(0)
            # 将客户端对象也加入到监听的列表中，当客户端发送消息时 select将触发
            inputs.append(connection)
            # 为连接的客户端单独创建一个消息队列，用来保存客户端发送的消息
            message_queues[connection] = Queue()
        else:
            # 有老用户发消息，处理
            data = s.recv(1024)
            # 客户端未断开
            if data != b"":
                print("received %s from %s"%(data,s.getpeername()))
                message_queues[s].put(data)
                if s not in outputs:
                    outputs.append(s)
            else:
                if s in outputs:
                    outputs.remove(s)
                inputs.remove(s)
                s.close()
                del message_queues[s]
    for s in writable:
        try:
            message_queue = message_queues.get(s)
            send_data = ""
            if message_queue is not None:
                send_data = message_queue.get_nowait()
            else:
                print("客户端断开了")
        except Queue.empty():
            print("客户端断开了")
            outputs.remove(s)
        else:
            if message_queue is not None:
                s.send(send_data)
            else:
                print("hash closed")

    # 处理异常情况
    for s in exceptional:
        inputs.remove(s)
        if s in outputs:
            outputs.remove(s)
        s.close()
        del message_queues[s]
    sleep(1)

客户端代码

import socket
messages = ['This is the message ', 'It will be sent ', 'in parts ', ]

server_address = ('localhost', 8090)

# Create aTCP/IP socket

socks = [socket.socket(socket.AF_INET, socket.SOCK_STREAM), socket.socket(socket.AF_INET,  socket.SOCK_STREAM), ]

# Connect thesocket to the port where the server is listening

print ('connecting to %s port %s' % server_address)
# 连接到服务器
for s in socks:
    s.connect(server_address)

for index, message in enumerate(messages):
    # Send messages on both sockets
    for s in socks:
        print ('%s: sending "%s"' % (s.getsockname(), message + str(index)))
        s.send(message.encode('utf8'))
    # Read responses on both sockets

for s in socks:
    data = s.recv(1024)
    print ('%s: received "%s"' % (s.getsockname(), data))
    if data != "":
        print ('closingsocket', s.getsockname())
        s.close()

poll

poll的原理

poll本质上和select没有区别，只是没有了最大连接数（linux上默认1024个）的限制，原因是它基于链表存储的。

poll的缺点

poll除了没有最大连接数的缺点，其他都和select一样。

在python中调用poll

select.poll(),返回一个poll对象，支持注册和注销文件描述符
poll.registed(fd[,eventmask]) 注册一个文件描述符，注册后，可以通过poll()方法来检查是否由对应的I/O事件发生。fd可以是i个整数，或者有返回的整数的filenoe()方法对象。如果File对象实现了fileno()，也可以当做参数使用。
eventmask是一个你想去检查的时间类型，它可以是常量POLLIN，POLLPRI和POLLOUT的组合。如果缺省，默认会去检查所有的3种事件类型
- POLLIN：有数据读取
- POLLPRT：有数据紧急读取
- POLLOUT：准备输出：输出不会阻塞
- POLLERR：某些错误情况出现
- POLLHUB：挂起
- POLLNVAL：无效请求，描述无法打开
poll.modify(fd,eventmask)修改一个已经存在的fd，和poll.register(fd,eventmask)有相同的作用。如果去尝试修改一个未经注册的fd，会引起一个errno为ENOENT的IOError
poll.unregister(fd)从poll对象中注销一个fd。尝试去注销一个未经注册的fd，会引起KeyError
poll.poll([timeout])去检测已经注册了的文件描述符。会返回一个可能为空的list，list中包含着(fd,event)这样的二元祖。fd是文件描述符，event是文件描述符对应的时间。如果返回是一个空的list，则说明了超时了且没有文件描述符有事件发生。timeout的单位是milliseconds，如果设置了timeout，系统将会等待对应的时间。如果timeout缺省或者是None，这个方法将会阻塞知道对应的poll对象有时间发生。

import select

def create_srv_socket(address):
    '''建立并返回一个服务器监听socket'''
    listener = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    listener.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
    listener.bind(address)
    listener.listen(64)
    print("Listening at  {}".format(address))
    return listener

def all_events_forever(poll_object):
    while True:
        for fd,event in poll_object.poll():
            yield fd,event

def serve(listener):
    sockets = {listener.fileno():listener} # 创建一个字典保存所有的sock
    addresses = {}
    bytes_received = {} # 缓存接受的数据
    bytes_to_send = {} # 缓存发送的数据

    poll_object = select.poll()
    poll_object.register(listener,select.POLLIN) # 注册一个读取的poll对象

    for fd,event in all_events_forever(poll_object): # 利用生成器，去读描述符和事件
        sock = socket[fd] # 取得sock
        if event & (select.POLLHUB |select.POLLERR | select.POLLNVAL) # 如果事件是挂起、错误或无效请求，则删除
            address = addresses.pop(sock)
            rb = bytes_received.pop(sock,b"")
            sb = bytes_to_send.pop(sock,b"")
            if rb:
                print("Client {} send {} but then closed".format(address,rb))
            elif sb:
                print("Client {} closed before we send {}".format(address,sb))
            else:
                print("Client {} closed socket normally".format(address))
            poll_object.unregister(fd) # 注销一个fd
            del sockets[fd]
        elif sock is listener: # 如果有监听者事件，说明有新的客户端连接
            sock,address = sock.accept()
            print("Accepted connection from {}".format(address))
            sock.setblocking(False)
            sockets[sock.fileno()] = sock
            address[sock] = address
            poll_object.register(sock,select.POLLIN)
        elif event & select.POLLIN: # 如果有读事件
            more_data = sock.recv(4096)
            if not mort_data: # 数据读完了
                sock.close()
                continue
            data = bytes_received.pop(sock,b"") +more_data
            if data.endswith(b"?"):
                bytes_to_send[sock] = data
                poll_object.modify(sock,select.POLLOUT) # 读完了改成写
            else:
                bytes_received[sock] = data
        elif event & select.POLLOUT:
            data = bytes_to_send.pop(sock)
            n = sock.send(data)
            if n <len(data):
                bytes_to_send[sock] = data[n:] 
            else：
                poll_object.modify(sock,select.POLLIN)
if __main__ == "__main__":
    address = 
    listener = create_srv_socket(address)
    server(listener)

epoll

epoll的原理与改进

在linux由内核直接支持的方法。epoll解决了select和poll的缺点。

对于第一个缺点，epoll的解决方法是每次注册新的事件到epoll中，会把所有的fd拷贝进内核，而不是在等待的时候重新拷贝，保证了每个fd在整个过程中只会拷贝1次。
对于第二个缺点，epoll没有这个限制，它所支持的fd上限是最大可以打开文件的数据，具体数据可以cat /proc/sys/fs/file_max查看，一般来说这个数目和系统内存关系比较大。
对于第三个缺点，epoll的解决方法不像select和poll每次对所有fd进行遍历轮询所有fd集合，而是在注册新的事件时，为每个fd指定一个回调函数，当设备就绪的时候，调用这个回调函数，这个回调函数就会把就绪的fd加入一个就绪表中。所以epoll只需要遍历就绪表

epoll同时支持水平触发和边缘触发：

水平触发：只要满足条件，就触发一个事件（只要有数据没有被获取，内核就不断通知你）。例如：在水平触发模式下，重复调用epoll.poll()会重复通知关注的event，直到与该even有关的所有数据都已被处理。
边缘触发：每当状态变化时，触发一个事件。例如：在边缘触发模式中，epoll.poll()在读或者写event在socket上发生后，将只会返回一次event。调用epoll.poll()的程序必须处理所有的和这个event相关的数据，随后的epoll.poll()调用不会再有这个event的通知。

使用DefaultSelector

python中的DefaultSelector库，该模块封装了高效的I/O多路复用，该模块根据使用的平台，选择该平台下最高效的I/O多路复用实现（select()、poll()、epoll())

利用DefaultSelector实现一个请求网页的的功能

该例子可以让我们更清楚的理解什么叫事件循环，下述代码中，我们在初始化中创建了一个非阻塞的socket，将其与目标服务器连接后，就紧接着为该socket注册了一个 写事件 的回调函数。在 写事件的回调函数中，我们注册了一个读事件的回调函数。我认为最关键的就在于如何理解loop函数，selector.select()函数是一个阻塞函数，当注册的socket有活跃的响应，才会返回值，这样，我们就可以遍历返回值，找到活跃的socket调用响应的回调函数。利用这里例子，尝试写一个聊天室的服务器。

import socket
from selectors import DefaultSelector, EVENT_READ, EVENT_WRITE
from urllib.parse import urlparse

selector = DefaultSelector()
stop = False

class Fetcher:
    def __init__(self,url):
        self.url = url
        self.url = urlparse(self.url)
        self.host = self.url.netloc
        self.path = self.url.path
        self.data = b""
        if self.path == "":
            self.path = "/"
        self.client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        self.client.setblocking(False)
        try:
            self.client.connect((self.host,80))
        except BlockingIOError as e:
            pass
        selector.register(self.client.fileno(),EVENT_WRITE,self.connected)

    def connected(self,key):

        selector.unregister(key.fd)
        try:
            self.client.send("GET {} HTTP/1.1\r\nHost:{}\r\nConnection:close\r\n\r\n".format(self.path,self.host).encode("utf8"))
        except BrokenPipeError as e:
            pass
        selector.register(self.client.fileno(),EVENT_READ,self.readable)

    def readable(self,key):
        d = self.client.recv(1024)
        if d:
            self.data += d
        else:
            selector.unregister(key.fd)
            data = self.data.decode("utf8")
            html_data = data.split("\r\n\r\n")[1]
            print(html_data)
            self.client.close()
            global stop
            stop = True



def loop():
    # 模拟了一个事件循环，注意事件循环需要我们自己实现，而不是操作系统去实现。
    while not stop:
        ready = selector.select()
        for key,mask in ready:
            call_back = key.data
            call_back(key)

if __name__ == '__main__':
    f = Fetcher("http://www.baidu.com")
    loop()

下面我们尝试实现一个聊天室的服务器

# encoding:utf8

# 聊天服务器，基于selector
# 简单描述逻辑
# 1. 拥有loop函数，事件循环
# 2. 初始化selecotr,socket,已存在的描述符集合
import socket
from selectors import DefaultSelector, EVENT_READ, EVENT_WRITE
class chatServer:
    def __init__(self):
        self.selector = DefaultSelector()
        self.socketFds = []
        self.serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 创建服务器socket
        self.serverSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.serverSocket.setblocking(False)  # 设置服务器socket为非阻塞
        self.serverSocket.bind(("localhost", 10000))  # 设置服务器socket监听("127.0.0.1",8001)
        self.serverSocket.listen(10)
        self.selector.register(self.serverSocket, EVENT_READ, self.serverSocketAccept)  # 为服务器socket注册读事件的回调函数
        # self.selector.register(self.serverSocket.fileno(),EVENT_WRITE,self.serverSocketWrite) # 为服务器socket注册读事件的回调函数
        self.clientData = {}  # 每一个socket对应一个消息缓冲区，当
        self.nameClient = {}  # 每一个socket对应一个用户名
        self.loop()

    def loop(self):
        while True:
            ready = self.selector.select()
            for key, mask in ready:
                call_back = key.data
                call_back(key.fileobj, mask)

    def serverSocketAccept(self, sock, mask):
        '''
        当服务器socket可读时，说明有新的客户端连接上了。
        '''
        conn, addr = self.serverSocket.accept()  # 新连接
        conn.send(b"what's your name?")
        conn.setblocking(False)
        self.clientData[conn] = []  # 每一个socket对应一个消息存储区
        self.nameClient[conn] = ""  # 每个socket对应一个用户名
        self.socketFds.append(conn)  # 添加新的socket
        self.selector.register(conn, EVENT_READ, self.clientRead)

    def clientRead(self, conn, mask):
        data = conn.recv(2)  # 从客户端的socket读取数据
        self.clientData[conn].append(data.decode('utf8'))  # 向消息存储区中存储数据
        if data.endswith(b"\n"):
            # 该socket读完了，从消息存储区中取得数据
            message = "".join(self.clientData[conn])
            self.clientData[conn].clear()

            if not self.nameClient[conn]:
                # 如果没有用户名
                self.nameClient[conn] = message
            else:
                for sock in self.socketFds:
                    if sock != conn:
                        sock.send((self.nameClient[conn] + " say:" + message).encode('utf8'))
if __name__ == '__main__':
    chatServer = chatServer()

油炸板蓝根

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
PythonIO多路复用

python IO 多路复用 select poll epollselectselect原理select是通过系统调用来监视着一个由多个文件描述符组成的数组，当select()返回后，数组中就绪的文件描述符会被内核修改标记位，使得进程可以获得这些文件描述符从而进行后续的读写操作。select是通过遍历来监视整个数组的，而且每次遍历都是线性的。select优点select目前几乎在所有的平...
复制链接

扫一扫