class Future(object):    ‘‘‘        Future对象主要保存一个回调函数列表_callbacks与一个执行结果_result，当我们set_result时，就会执行_callbacks中的函数    ‘‘‘    def __init__(self):        self._done = False  # 是否执行完成        self._result = None    # 执行的结果        self._exc_info = None    # 执行的异常信息        self._log_traceback = False   # Used for Python >= 3.4        self._tb_logger = None        # Used for Python <= 3.3        self._callbacks = []    # 用来保存该future对象的回调函数    # Implement the Python 3.5 Awaitable protocol if possible    # (we can‘t use return and yield together until py33).    if sys.version_info >= (3, 3):        exec(textwrap.dedent("""        def __await__(self):            return (yield self)        """))    else:        # Py2-compatible version for use with cython.        def __await__(self):            result = yield self            # StopIteration doesn‘t take args before py33,            # but Cython recognizes the args tuple.            e = StopIteration()            e.args = (result,)            raise e    def cancel(self):        """Cancel the operation, if possible. 如果可能的话取消操作        tornado对象不支持取消操作，所以总是返回False        """        return False    def cancelled(self):        # 同上        return False    def running(self):        """Returns True if this operation is currently running."""        return not self._done    def done(self):        """Returns True if the future has finished running."""        return self._done    def _clear_tb_log(self):        self._log_traceback = False        if self._tb_logger is not None:            self._tb_logger.clear()            self._tb_logger = None    def result(self, timeout=None):        """If the operation succeeded, return its result.  If it failed,        re-raise its exception. 如果操作成功，返回结果。如果失败则抛出异常        This method takes a ``timeout`` argument for compatibility with        `concurrent.futures.Future` but it is an error to call it        before the `Future` is done, so the ``timeout`` is never used.        """        self._clear_tb_log()        if self._result is not None:            return self._result        if self._exc_info is not None:            raise_exc_info(self._exc_info)        self._check_done()        return self._result    def exception(self, timeout=None):        """If the operation raised an exception, return the `Exception`        object.  Otherwise returns None.        This method takes a ``timeout`` argument for compatibility with        `concurrent.futures.Future` but it is an error to call it        before the `Future` is done, so the ``timeout`` is never used.        """        self._clear_tb_log()        if self._exc_info is not None:            return self._exc_info[1]        else:            self._check_done()            return None    def add_done_callback(self, fn):        """Attaches the given callback to the `Future`. 将callback附加到        It will be invoked with the `Future` as its argument when the Future        has finished running and its result is available.  In Tornado        consider using `.IOLoop.add_future` instead of calling        `add_done_callback` directly.        """        if self._done:            fn(self)        else:            self._callbacks.append(fn)    def set_result(self, result):        """Sets the result of a ``Future``. 将 result 设置为该future对象的结果        It is undefined to call any of the ``set`` methods more than once        on the same object.        """        self._result = result        self._set_done()    def set_exception(self, exception):        """Sets the exception of a ``Future.``"""        self.set_exc_info(            (exception.__class__,             exception,             getattr(exception, ‘__traceback__‘, None)))    def exc_info(self):        """Returns a tuple in the same format as `sys.exc_info` or None.        .. versionadded:: 4.0        """        self._clear_tb_log()        return self._exc_info    def set_exc_info(self, exc_info):        """Sets the exception information of a ``Future.``        Preserves tracebacks on Python 2.        .. versionadded:: 4.0        """        self._exc_info = exc_info        self._log_traceback = True        if not _GC_CYCLE_FINALIZERS:            self._tb_logger = _TracebackLogger(exc_info)        try:            self._set_done()        finally:            # Activate the logger after all callbacks have had a            # chance to call result() or exception().            if self._log_traceback and self._tb_logger is not None:                self._tb_logger.activate()        self._exc_info = exc_info    def _check_done(self):        if not self._done:            raise Exception("DummyFuture does not support blocking for results")    def _set_done(self):        # 执行结束(成功)后的操作。        self._done = True        for cb in self._callbacks:            try:                cb(self)            except Exception:                app_log.exception(‘Exception in callback %r for %r‘, cb, self)        self._callbacks = None    # On Python 3.3 or older, objects with a destructor part of a reference    # cycle are never destroyed. It‘s no longer the case on Python 3.4 thanks to    # the PEP 442.    if _GC_CYCLE_FINALIZERS:        def __del__(self):            if not self._log_traceback:                # set_exception() was not called, or result() or exception()                # has consumed the exception                return            tb = traceback.format_exception(*self._exc_info)            app_log.error(‘Future %r exception was never retrieved: %s‘,                          self, ‘‘.join(tb).rstrip())

def run():    print(‘start running‘)    yield 2     # 跑步用时2小时def eat():    print(‘start eating‘)    yield 1     # 吃饭用时1小时def time():    run_time = yield run()    eat_time = yield eat()    print(run_time+eat_time)def Runner(gen):    r = next(gen)    return rt = time()try:    action = t.send(Runner(next(t)))    t.send(Runner(action))except StopIteration:    pass

class Runner(object):    def __init__(self, gen, result_future, first_yielded):        self.gen = gen                        # 一个generator对象        self.result_future = result_future    # 一个Future对象        self.future = _null_future            # 一个刚初始化的Future对象  _null_future = Future(); _null_future.set_result(None)        self.yield_point = None        self.pending_callbacks = None        self.results = None        self.running = False        self.finished = False        self.had_exception = False        self.io_loop = IOLoop.current()        self.stack_context_deactivate = None        if self.handle_yield(first_yielded):            self.run()        ………… 部分方法省略    def run(self):        """Starts or resumes the generator, running until it reaches a        yield point that is not ready.        """        if self.running or self.finished:            return        try:            self.running = True            while True:                future = self.future                if not future.done():                    return                self.future = None                try:                    orig_stack_contexts = stack_context._state.contexts                    exc_info = None                    try:                        value = future.result()                    except Exception:                        self.had_exception = True                        exc_info = sys.exc_info()                    if exc_info is not None:                        yielded = self.gen.throw(*exc_info)                        exc_info = None                    else:                        yielded = self.gen.send(value)                    if stack_context._state.contexts is not orig_stack_contexts:                        self.gen.throw(                            stack_context.StackContextInconsistentError(                                ‘stack_context inconsistency (probably caused ‘                                ‘by yield within a "with StackContext" block)‘))                except (StopIteration, Return) as e:                    self.finished = True                    self.future = _null_future                    if self.pending_callbacks and not self.had_exception:                        # If we ran cleanly without waiting on all callbacks                        # raise an error (really more of a warning).  If we                        # had an exception then some callbacks may have been                        # orphaned, so skip the check in that case.                        raise LeakedCallbackError(                            "finished without waiting for callbacks %r" %                            self.pending_callbacks)                    self.result_future.set_result(_value_from_stopiteration(e))                    self.result_future = None                    self._deactivate_stack_context()                    return                except Exception:                    self.finished = True                    self.future = _null_future                    self.result_future.set_exc_info(sys.exc_info())                    self.result_future = None                    self._deactivate_stack_context()                    return                if not self.handle_yield(yielded):                    return        finally:            self.running = False    def handle_yield(self, yielded):        if _contains_yieldpoint(yielded):    # 检查其中是否包含YieldPoint            yielded = multi(yielded)        if isinstance(yielded, YieldPoint):        # Base class for objects that may be yielded from the generator            self.future = TracebackFuture()        # 一个刚刚初始化的Future对象            def start_yield_point():                try:                    yielded.start(self)                    if yielded.is_ready():                        self.future.set_result(yielded.get_result())                    else:                        self.yield_point = yielded                except Exception:                    self.future = TracebackFuture()                    self.future.set_exc_info(sys.exc_info())            if self.stack_context_deactivate is None:                with stack_context.ExceptionStackContext(self.handle_exception) as deactivate:                    self.stack_context_deactivate = deactivate                                        def cb():                        start_yield_point()                        self.run()                    self.io_loop.add_callback(cb)                    return False            else:                start_yield_point()        else:            try:                self.future = convert_yielded(yielded)            except BadYieldError:                self.future = TracebackFuture()                self.future.set_exc_info(sys.exc_info())        if not self.future.done() or self.future is moment:  # moment = Future()            self.io_loop.add_future(self.future, lambda f: self.run()) # 为该future添加callback            return False        return True