Tornado 高并发源码分析之五--- IOLoop 对象

IOLoop主要工作

1、将TCPServer 注册到 IOLoop 的事件记到 _handlers 字段，同时注册 READ 和 ERROR 事件到 epoll

2、IOLoop 启动一个大循环，负责轮询epoll中是否已经有就绪的事件，如果有就执行对应的回调

 

以下为源码分析，省略部分源码，只取主要部分

class Configurable(object):
    """根据子类的配置，来创建一个对象，也就是说，继承自Configurable的子类，可以自己配置产生不同的类，并且每个类都会执行initialize方法
    __impl_class = None
    __impl_kwargs = None

    def __new__(cls, **kwargs):   
        base = cls.configurable_base()
        args = {}
        if cls is base:
            impl = cls.configured_class()
            if base.__impl_kwargs:
                args.update(base.__impl_kwargs)
        else:
            impl = cls
        args.update(kwargs)
        instance = super(Configurable, cls).__new__(impl)
        instance.initialize(**args)   #执行initialize方法
        return instance

class IOLoop(Configurable):
" 一个大循环，自动根据当前的系统，是 linux 2.5以上选择epoll， mac 选择kqueue， 其他选择select".
@staticmethod
def instance():   #创建一个全局的 IOLoop 单例
    if not hasattr(IOLoop, "_instance"):
        with IOLoop._instance_lock:
            if not hasattr(IOLoop, "_instance"):
                IOLoop._instance = IOLoop()
    return IOLoop._instance


@classmethod    配置
def configurable_base(cls):
    return IOLoop

@classmethod
def configurable_default(cls):   #根据系统，配置使用epoll还是 kqueue
    if hasattr(select, "epoll"):
        from tornado.platform.epoll import EPollIOLoop
        return EPollIOLoop
    if hasattr(select, "kqueue"):
        # Python 2.6+ on BSD or Mac
        from tornado.platform.kqueue import KQueueIOLoop
        return KQueueIOLoop
    from tornado.platform.select import SelectIOLoop
    return SelectIOLoop

class PollIOLoop(IOLoop):
"继承自IOLoop， 就是IOLoop 在根据系统选择的时候，真正创建的类对象"

def add_handler(self, fd, handler, events):
    fd, obj = self.split_fd(fd)
    self._handlers[fd] = (obj, stack_context.wrap(handler))    #将socket对象的句柄fd作为key， 回调函数handler作为值，添加到 _handlers 字段中， 其实这里的函数就是在TCPServer 启动时添加的 _handle_connection 方法
    self._impl.register(fd, events | self.ERROR)   #向_impl (在linux中是epoll，在mac中是kqueue，2.5版本一下的linux中是select)中注册对应句柄fd 的事件(其实就是READ和error事件)

def start(self):
  
    try:
        while True:   #启动IOLoop 大循环， 这是一个无限循环
   
            with self._callback_lock:   #如果有上一个循环没有执行完毕的函数，继续拿出来执行
                callbacks = self._callbacks
                self._callbacks = []

        
            try:
                event_pairs = self._impl.poll(poll_timeout)   #从epoll中取出已经就绪的事件
            except Exception as e:
                if errno_from_exception(e) == errno.EINTR:
                    continue
                else:
                    raise

            self._events.update(event_pairs)   #将事件更新到 _events dict中
            while self._events:
                fd, events = self._events.popitem()
                try:
                    fd_obj, handler_func = self._handlers[fd]   #从刚开始添加事件到_handler里面取出对应的回调函数
                    handler_func(fd_obj, events)  #执行回调函数， 其实也就是执行TCPServer中的self._handle_connection 方法
                except (OSError, IOError) as e:
                        self.handle_callback_exception(self._handlers.get(fd))
                except Exception:
                    self.handle_callback_exception(self._handlers.get(fd))
            fd_obj = handler_func = None   #清空，准备进入下一次循环

    finally:
       ignal.set_wakeup_fd(old_wakeup_fd)