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

Configurable

 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

IOLoop

 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)

PollIOLoop