ioloop分析

咱们先来简单说一下ioloop的源码
  1. while True:
  2.     poll_timeout = 3600.0
  4.     # Prevent IO event starvation by delaying new callbacks
  5.     # to the next iteration of the event loop.
  6.     with self._callback_lock:
  7.         ＃上次循环的回调列表
  8.         callbacks = self._callbacks
  9.         self._callbacks = []
  10.     for callback in callbacks:
  11.         ＃执行遗留回调
  12.         self._run_callback(callback)
  14.     if self._timeouts:
  15.         now = self.time()
  16.         while self._timeouts:
  17.             ＃超时回调
  18.             if self._timeouts[0].callback is None:
  19.                 # 最小堆维护超时事件
  20.                 heapq.heappop(self._timeouts)
  21.             elif self._timeouts[0].deadline <= now:
  22.                 timeout = heapq.heappop(self._timeouts)
  23.                 self._run_callback(timeout.callback)
  24.             else:
  25.                 seconds = self._timeouts[0].deadline - now
  26.                 poll_timeout = min(seconds, poll_timeout)
  27.                 break
  29.     if self._callbacks:
  30.         # If any callbacks or timeouts called add_callback,
  31.         # we don't want to wait in poll() before we run them.
  32.         poll_timeout = 0.0
  34.     if not self._running:
  35.         break
  37.     if self._blocking_signal_threshold is not None:
  38.         # clear alarm so it doesn't fire while poll is waiting for
  39.         # events.
  40.         signal.setitimer(signal.ITIMER_REAL, 0, 0)
  42.     try:
  43.         ＃这里的poll就是epoll，当有事件发生，就会返回，详情参照tornado里e＃poll的代码
  44.         event_pairs = self._impl.poll(poll_timeout)
  45.     except Exception as e:
  46.         if (getattr(e, 'errno', None) == errno.EINTR or
  47.             (isinstance(getattr(e, 'args', None), tuple) and
  48.              len(e.args) == 2 and e.args[0] == errno.EINTR)):
  49.             continue
  50.         else:
  51.             raise
  53.     if self._blocking_signal_threshold is not None:
  54.         signal.setitimer(signal.ITIMER_REAL,
  55.                          self._blocking_signal_threshold, 0)
  57.     ＃如果有事件发生，添加事件，
  58.     self._events.update(event_pairs)
  59.     while self._events:
  60.         fd, events = self._events.popitem()
  61.         try:
  62.             ＃根据fd找到对应的回调函数，
  63.             self._handlers[fd](fd, events)
  64.         except (OSError, IOError) as e:
  65.             if e.args[0] == errno.EPIPE:
  66.                 # Happens when the client closes the connection
  67.                 pass
  68.             else:
  69.                 app_log.error("Exception in I/O handler for fd %s",
  70.                               fd, exc_info=True)
  71.         except Exception:
  72.             app_log.error("Exception in I/O handler for fd %s",
  73.                           fd, exc_info=True)
简单来说一下流程，首先执行上次循环的回调列表，然后调用epoll等待事件的发生，根据fd取出对应的回调函数，然后执行。IOLoop基本是个事件循环，因此它总是被其它模块所调用。
咱们来看一下ioloop的start方法，start 方法中主要分三个部分：一个部分是对超时的相关处理；一部分是 epoll 事件通知阻塞、接收；一部分是对 epoll 返回I/O事件的处理。

1.超时的处理，是用一个最小堆来维护每个回调函数的超时时间，如果超时，取出对应的回调，如果没有则重新设置poll_timeout的值

2.通过 self._impl.poll(poll_timeout) 进行事件阻塞，当有事件通知或超时时 poll 返回特定的 event_pairs，这个上面也说过了。