抽空看了下tornado的源码，会将几个关键部分以专栏文章的形式记录下来，算是对学习的一个汇总，也希望能对使用tornado的朋友有所启迪，文中有任何说的不到位的地方，欢迎私信或者评论指出。

看开源项目代码时，我会直接选择最原始的版本，tornadoweb/tornado，因为我认为最核心的功能往往在v1.0.0都具备，后续很少有对大功能的改进，而且随着各路开源人士代码的提交，项目的代码风格未必会完全的一致。

本文会介绍 ioloop.py， 看下文之前，需要你已经了解了Linux的IO模型，如果没有的话推荐看下《Unix的网络编程卷》。

那么开始吧!

# Choose a poll implementation. Use epoll if it is available, fall back to
# select() for non-Linux platforms
if hasattr(select, "epoll"):
    # Python 2.6+ on Linux
    _poll = select.epoll
elif hasattr(select, "kqueue"):
    # Python 2.6+ on BSD or Mac
    _poll = _KQueue
else:
    try:
        # Linux systems with our C module installed
        import epoll
        _poll = _EPoll
    except:
        # All other systems
        import sys
        if "linux" in sys.platform:
            logging.warning("epoll module not found; using select()")
        _poll = _Select

Linux中的epoll模型在不同的平台上有不同的叫法，Linux下叫epoll，mac或者bsd上叫kqueue，它们本质上都是IO复用的一种形式，Python 2.6+的select库中包含了对应的实现，但是2.6以下的版本没有对应的实现，tornado使用C语言模块的实现并简单包装了下，2.6以下版本就用tornado包装的epoll。上述代码就是干这个事情的，根据系统平台和Python的版本选择对应的epoll实现。

那么对应的epoll实现都包含了哪些功能呢？我们看下其中的_EPOLL，这是其中的一个实现，tornado对底层做了包装。

class _EPoll(object):
    """An epoll-based event loop using our C module for Python 2.5 systems"""
    _EPOLL_CTL_ADD = 1
    _EPOLL_CTL_DEL = 2
    _EPOLL_CTL_MOD = 3

    def __init__(self):
        self._epoll_fd = epoll.epoll_create()

    def fileno(self):
        return self._epoll_fd

    def register(self, fd, events):
        epoll.epoll_ctl(self._epoll_fd, self._EPOLL_CTL_ADD, fd, events)

    def modify(self, fd, events):
        epoll.epoll_ctl(self._epoll_fd, self._EPOLL_CTL_MOD, fd, events)

    def unregister(self, fd):
        epoll.epoll_ctl(self._epoll_fd, self._EPOLL_CTL_DEL, fd, 0)

    def poll(self, timeout):
        return epoll.epoll_wait(self._epoll_fd, int(timeout * 1000))

我们可以看出，对外提供的就是epoll常规的几个功能，了解过epoll的一看便知。

接下来我们看下IOLOOP这个类的代码，按照从上到下的顺序：

# Constants from the epoll module
_EPOLLIN = 0x001
_EPOLLPRI = 0x002
_EPOLLOUT = 0x004
_EPOLLERR = 0x008
_EPOLLHUP = 0x010
_EPOLLRDHUP = 0x2000
_EPOLLONESHOT = (1 << 30)
_EPOLLET = (1 << 31)

# Our events map exactly to the epoll events
NONE = 0
READ = _EPOLLIN
WRITE = _EPOLLOUT
ERROR = _EPOLLERR | _EPOLLHUP | _EPOLLRDHUP

这里定义了epoll中的事件，我们比较关注的是_EPOLLIN和_EPOLLOUT，分别表示我们关心的fd（文件描述符）可写了或者可读了。

def __init__(self, impl=None):
    self._impl = impl or _poll()
    if hasattr(self._impl, 'fileno'):
        self._set_close_exec(self._impl.fileno())
    self._handlers = {}
    self._events = {}
    self._callbacks = set()
    self._timeouts = []
    self._running = False
    self._stopped = False
    self._blocking_log_threshold = None

    # Create a pipe that we send bogus data to when we want to wake
    # the I/O loop when it is idle
    if os.name != 'nt':
        r, w = os.pipe()
        self._set_nonblocking(r)
        self._set_nonblocking(w)
        self._set_close_exec(r)
        self._set_close_exec(w)
        self._waker_reader = os.fdopen(r, "r", 0)
        self._waker_writer = os.fdopen(w, "w", 0)
    else:
        self._waker_reader = self._waker_writer = win32_support.Pipe()
        r = self._waker_writer.reader_fd
    self.add_handler(r, self._read_waker, self.READ)

这里解释两个地方。

_set_close_exec方法是干嘛的？

def _set_close_exec(self, fd):
    flags = fcntl.fcntl(fd, fcntl.F_GETFD)
    fcntl.fcntl(fd, fcntl.F_SETFD, flags | fcntl.FD_CLOEXEC)

Linux在fork子进程时使用写时复制的策略，假设原有进程对某个文件持有fd，fork后，子进程也会有相应的fd对应那个文件，但是子进程如果仅仅是被fork来exec的，那么在exec时会有新的上下文及变量，原来持有的那个文件描述符就不见了，设置了这个位，当子进程执行exec的时候，所持有的fd就会被关闭。

r, w = os.pipe()是在干嘛？

开启了一个管道，并设置读写均为nonblocking，当read或write被阻塞，将返回-1或者EAGAIN错误。

设置这个管道为了高效率的让IO Loop停止循环，只要在通道另一侧写点什么，就会阻塞poll()方法。

@classmethod 
def instance(cls):
    """Returns a global IOLoop instance.

    Most single-threaded applications have a single, global IOLoop.
    Use this method instead of passing around IOLoop instances
    throughout your code.

    A common pattern for classes that depend on IOLoops is to use
    a default argument to enable programs with multiple IOLoops
    but not require the argument for simpler applications:

        class MyClass(object):
            def __init__(self, io_loop=None):
                self.io_loop = io_loop or IOLoop.instance()
    """
if not hasattr(cls, "_instance"):
        cls._instance = cls()
return cls._instance

instance方法就是实现单例的，不多介绍。

def add_handler(self, fd, handler, events):
    """Registers the given handler to receive the given events for fd."""
    self._handlers[fd] = handler
self._impl.register(fd, events | self.ERROR)

def update_handler(self, fd, events):
    """Changes the events we listen for fd."""
    self._impl.modify(fd, events | self.ERROR)

def remove_handler(self, fd):
    """Stop listening for events on fd."""
    self._handlers.pop(fd, None)
    self._events.pop(fd, None)
try:
    self._impl.unregister(fd)
except (OSError, IOError):
    logging.debug("Error deleting fd from IOLoop", exc_info=True)

这几个方法，就是负责给指定的fd绑定对应的handler以及监听的事件的。

def set_blocking_log_threshold(self, s):
    """Logs a stack trace if the ioloop is blocked for more than s seconds.
    Pass None to disable.  Requires python 2.6 on a unixy platform.
    """
    if not hasattr(signal, "setitimer"):
        logging.error("set_blocking_log_threshold requires a signal module "
                   "with the setitimer method")
        return
    self._blocking_log_threshold = s
    if s is not None:
        signal.signal(signal.SIGALRM, self._handle_alarm)

def _handle_alarm(self, signal, frame):
    logging.warning('IOLoop blocked for %f seconds in\n%s',
                 self._blocking_log_threshold,
                 ''.join(traceback.format_stack(frame)))

使用signal模块来监控Ioloop的block时间，超过某个时间就会触发我们自己定义的handler。signal.SIGALRM和signal.ITIMER_REAL一般配合使用。

加下来就是最重要的start方法，start方法下还有几个小方法，将在这里一并介绍。

def start(self):
    """Starts the I/O loop.

    The loop will run until one of the I/O handlers calls stop(), which
    will make the loop stop after the current event iteration completes.
    """
    if self._stopped:
        self._stopped = False
        return
    self._running = True
    while True:
        # Never use an infinite timeout here - it can stall epoll
        poll_timeout = 0.2

        # Prevent IO event starvation by delaying new callbacks
        # to the next iteration of the event loop.
        callbacks = list(self._callbacks)
        for callback in callbacks:
            # A callback can add or remove other callbacks
            if callback in self._callbacks:
                self._callbacks.remove(callback)
                self._run_callback(callback)

        if self._callbacks:
            poll_timeout = 0.0


        if self._timeouts:
            now = time.time()
            while self._timeouts and self._timeouts[0].deadline <= now:
                timeout = self._timeouts.pop(0)
                self._run_callback(timeout.callback)
            if self._timeouts:
                milliseconds = self._timeouts[0].deadline - now
                poll_timeout = min(milliseconds, poll_timeout)

        if not self._running:
            break

        if self._blocking_log_threshold is not None:
            # clear alarm so it doesn't fire while poll is waiting for
            # events.
            signal.setitimer(signal.ITIMER_REAL, 0, 0)

        try:
            event_pairs = self._impl.poll(poll_timeout)
        except Exception, e:
            # Depending on python version and IOLoop implementation,
            # different exception types may be thrown and there are
            # two ways EINTR might be signaled:
            # * e.errno == errno.EINTR
            # * e.args is like (errno.EINTR, 'Interrupted system call')
            if (getattr(e, 'errno') == errno.EINTR or
                (isinstance(getattr(e, 'args'), tuple) and
                 len(e.args) == 2 and e.args[0] == errno.EINTR)):
                logging.warning("Interrupted system call", exc_info=1)
                continue
            else:
                raise

        if self._blocking_log_threshold is not None:
            signal.setitimer(signal.ITIMER_REAL,
                             self._blocking_log_threshold, 0)

        # Pop one fd at a time from the set of pending fds and run
        # its handler. Since that handler may perform actions on
        # other file descriptors, there may be reentrant calls to
        # this IOLoop that update self._events
        self._events.update(event_pairs)
        while self._events:
            fd, events = self._events.popitem()
            try:
                self._handlers[fd](fd, events)
            except (KeyboardInterrupt, SystemExit):
                raise
            except (OSError, IOError), e:
                if e[0] == errno.EPIPE:
                    # Happens when the client closes the connection
                    pass
                else:
                    logging.error("Exception in I/O handler for fd %d",
                                  fd, exc_info=True)
            except:
                logging.error("Exception in I/O handler for fd %d",
                              fd, exc_info=True)
    # reset the stopped flag so another start/stop pair can be issued
    self._stopped = False
    if self._blocking_log_threshold is not None:
        signal.setitimer(signal.ITIMER_REAL, 0, 0)

_callbacks保存了一些函数，这些函数会在下一次IO loop事件循环前被调用，在任何时候任何线程中调用都是安全的，可用于将一些控件传输到ioloop的线程中。

_timeouts用户保存执行函数和deadline的对应关系，和_callbacks相比，它指定了函数执行时间，而_callback是在下一次Ioloop循环前立刻执行。

关于poll_timeout时间的设置问题

=0表示无论有没有就绪时间立刻返回

我们可以看到默认是0.2，当有_callback可以执行，我们把它设置为0，再看下过多长时间_timeout中有函数可以执行，取最小时间。

简单概括就是，如果_callback和_timeout都没有方法可以执行，就默认0.2，如果有方法可以执行，默认等待时间就是最快会执行方法到现在的时间间隔。

剩下 的部分就是用poll函数拿到就绪事件，然后用signal.ITIMER_REAL计时，开始处理，处理时候使用pop方法，而不是遍历，原因是fd和handler的映射关系可能在遍历过程修改，执行完成后，reset _stopped设置为false，关闭计时器。

关于ioloop的介绍就到这里，不正之处欢迎指出。