class IOLoop(Configurable):    ......

    @classmethod    def configurable_default(cls):        if hasattr(select, "epoll"):     # 因为我们假设我们的系统为Linux，且支持epoll，所以这里为True            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 EPollIOLoop(PollIOLoop):　　# 该类只有这么短短的几句，可见主要的方法是在其父类PollIOLoop中实现。    def initialize(self, **kwargs):        super(EPollIOLoop, self).initialize(impl=select.epoll(), **kwargs) # 执行了父类PollIOLoop的initialize方法，并将select.epoll()传入

class PollIOLoop(IOLoop):  # 从属配置子类    def initialize(self, impl, time_func=None, **kwargs):        super(PollIOLoop, self).initialize(**kwargs)                # 调用IOLoop的initialize方法        self._impl = impl                               # self._impl = select.epoll()        if hasattr(self._impl, ‘fileno‘):               # 文件描述符的close_on_exec属性            set_close_exec(self._impl.fileno())        self.time_func = time_func or time.time        self._handlers = {}                             # 文件描述符对应的fileno()作为key，(文件描述符对象,处理函数)作为value        self._events = {}                               # 用来存储epoll_obj.poll()返回的事件，也就是哪个fd发生了什么事件{(fd1, event1), (fd2, event2)……}        self._callbacks = []        self._callback_lock = threading.Lock()          # 添加线程锁        self._timeouts = []                             # 存储定时任务        self._cancellations = 0        self._running = False        self._stopped = False        self._closing = False        self._thread_ident = None                       # 获得当前线程标识符        self._blocking_signal_threshold = None        self._timeout_counter = itertools.count()        # Create a pipe that we send bogus data to when we want to wake        # the I/O loop when it is idle        self._waker = Waker()        self.add_handler(self._waker.fileno(),                         lambda fd, events: self._waker.consume(),                         self.READ)

    def initialize(self, make_current=None):        if make_current is None:            if IOLoop.current(instance=False) is None:                self.make_current()        elif make_current:            if IOLoop.current(instance=False) is not None:                raise RuntimeError("current IOLoop already exists")            self.make_current()
    @staticmethod    def current(instance=True):        current = getattr(IOLoop._current, "instance", None)        if current is None and instance:            return IOLoop.instance()        return current    def make_current(self):        IOLoop._current.instance = self

    def add_handler(self, fd, handler, events):        # 向epoll中注册事件 ， 并在self._handlers[fd]中为该文件描述符添加相应处理函数        fd, obj = self.split_fd(fd)   # fd.fileno(),fd        self._handlers[fd] = (obj, stack_context.wrap(handler))        self._impl.register(fd, events | self.ERROR)    def update_handler(self, fd, events):        fd, obj = self.split_fd(fd)        self._impl.modify(fd, events | self.ERROR)    def remove_handler(self, fd):        fd, obj = self.split_fd(fd)        self._handlers.pop(fd, None)        self._events.pop(fd, None)        try:            self._impl.unregister(fd)        except Exception:            gen_log.debug("Error deleting fd from IOLoop", exc_info=True)

    def add_callback(self, callback, *args, **kwargs):        # 因为Python的GIL的限制，导致Python线程并不算高效。加上tornado实现了多进程 + 协程的模式，所以我们略过源码中的部分线程相关的一些操作        if self._closing:            return        self._callbacks.append(functools.partial(stack_context.wrap(callback), *args, **kwargs))    def add_future(self, future, callback):        # 为future对象添加经过包装后的回调函数，该回调函数会在future对象被set_done后添加至_callbacks中        assert is_future(future)        callback = stack_context.wrap(callback)        future.add_done_callback(            lambda future: self.add_callback(callback, future))

def add_timeout(self, deadline, callback, *args, **kwargs):        """            ``deadline``可能是一个数字，表示相对于当前时间的时间（与“IOLoop.time”通常为“time.time”相同的大小），或者是datetime.timedelta对象。             自从Tornado 4.0以来，`call_later`是一个比较方便的替代方案，因为它不需要timedelta对象。        """        if isinstance(deadline, numbers.Real):            return self.call_at(deadline, callback, *args, **kwargs)        elif isinstance(deadline, datetime.timedelta):            return self.call_at(self.time() + timedelta_to_seconds(deadline),                                callback, *args, **kwargs)        else:            raise TypeError("Unsupported deadline %r" % deadline)

def start(self):        if self._running:            raise RuntimeError("IOLoop is already running")        self._setup_logging()        if self._stopped:            self._stopped = False            return        old_current = getattr(IOLoop._current, "instance", None)        IOLoop._current.instance = self        self._thread_ident = thread.get_ident()     # 获得当前线程标识符        self._running = True        old_wakeup_fd = None        if hasattr(signal, ‘set_wakeup_fd‘) and os.name == ‘posix‘:            # 需要Python2.6及以上版本，类UNIX系统，set_wake_up_fd存在。在windows系统上运行会崩溃            try:                old_wakeup_fd = signal.set_wakeup_fd(self._waker.write_fileno())                if old_wakeup_fd != -1:                    # Already set, restore previous value.  This is a little racy,                    # but there‘s no clean get_wakeup_fd and in real use the                    # IOLoop is just started once at the beginning.                    signal.set_wakeup_fd(old_wakeup_fd)                    old_wakeup_fd = None            except ValueError:                # Non-main thread, or the previous value of wakeup_fd                # is no longer valid.                old_wakeup_fd = None        try:            while True:                # 防止多线程模型时产生脏数据                with self._callback_lock:                        callbacks = self._callbacks                    self._callbacks = []                due_timeouts = []                if self._timeouts:         # 将时间已到的定时任务放置到due_timeouts中                    now = self.time()                    while self._timeouts:                        if self._timeouts[0].callback is None:                            heapq.heappop(self._timeouts)                            self._cancellations -= 1                        elif self._timeouts[0].deadline <= now:                            due_timeouts.append(heapq.heappop(self._timeouts))                        else:                            break                    if (self._cancellations > 512 and                            self._cancellations > (len(self._timeouts) >> 1)):                        self._cancellations = 0                        self._timeouts = [x for x in self._timeouts                                          if x.callback is not None]                        heapq.heapify(self._timeouts)                for callback in callbacks:        # 执行callbacks                    self._run_callback(callback)                for timeout in due_timeouts:    # 执行timeout_callback                    if timeout.callback is not None:                        self._run_callback(timeout.callback)                # 释放内存                callbacks = callback = due_timeouts = timeout = None                if self._callbacks: # 如果在执行callbacks 或者 timeouts的过程中，他们执行了add_callbacks ，那么这时：self._callbacks就非空了，                    # 为了尽快的执行其中的callbacks，我们需要将poll_timeout 设置为0，这样我们就不需要等待fd事件发生，尽快运行callbacks了                    poll_timeout = 0.0                elif self._timeouts:                    # If there are any timeouts, schedule the first one.                    # Use self.time() instead of ‘now‘ to account for time                    # spent running callbacks.                    poll_timeout = self._timeouts[0].deadline - self.time()                    poll_timeout = max(0, min(poll_timeout, _POLL_TIMEOUT))                else:                    # 如果没有回调函数也没有定时任务，我们就使用默认值                    poll_timeout = _POLL_TIMEOUT                if not self._running:    # 终止ioloop运行时，在执行完了callback后结束循环                    break                if self._blocking_signal_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 as e:                    # http://blog.csdn.net/benkaoya/article/details/17262053 解释EINTR是什么。系统调用被信号处理函数中断，进行下一次循环                    if errno_from_exception(e) == errno.EINTR:                        continue                    else:                        raise                if self._blocking_signal_threshold is not None:                    signal.setitimer(signal.ITIMER_REAL,                                     self._blocking_signal_threshold, 0)                # 从一组待处理的fds中一次弹出一个fd并运行其处理程序。                 # 由于该处理程序可能会对其他文件描述符执行操作，因此可能会重新调用此IOLoop来修改self._events                self._events.update(event_pairs)                while self._events:                    fd, events = self._events.popitem()             # 获取一个fd以及对应事件                    try:                        fd_obj, handler_func = self._handlers[fd]   # 获取该fd对应的事件处理函数                        handler_func(fd_obj, events)                # 运行该事件处理函数                    except (OSError, IOError) as e:                                 if errno_from_exception(e) == errno.EPIPE:                            # 当客户端关闭连接时会产生EPIPE错误                            pass                        else:                            self.handle_callback_exception(self._handlers.get(fd))                    except Exception:                        self.handle_callback_exception(self._handlers.get(fd))                # 释放内存空间                fd_obj = handler_func = None                                finally:            # reset the stopped flag so another start/stop pair can be issued            self._stopped = False             if self._blocking_signal_threshold is not None:                signal.setitimer(signal.ITIMER_REAL, 0, 0)            IOLoop._current.instance = old_current            if old_wakeup_fd is not None:                signal.set_wakeup_fd(old_wakeup_fd)

def close(self, all_fds=False):        with self._callback_lock:            self._closing = True        self.remove_handler(self._waker.fileno())        if all_fds:    # 该参数若为True，则表示会关闭所有文件描述符            for fd, handler in self._handlers.values():                self.close_fd(fd)        self._waker.close()        self._impl.close()         self._callbacks = None        self._timeouts = None