tornado.gen.coroutine-协程
1. yield的基本概念
2. Future的用法
3. ioloop的常用接口
4. gen.coroutine的应用
5. gen.coroutine的源码
6. Runner类的实现
1. yield的基本概念
python中使用yield实现了生成器函数，同样yield.send( )方法也实现了控制权在函数间的跳转。
关于yield比较详细的介绍，可以参考这篇博文http://www.cnblogs.com/coderzh/articles/1202040.html
2.Future的用法
Future是用来在异步过程中，存放结果的容器。它可以在结果出来时，进行回调。
add_done_callback(self, fn)： 添加回调函数fn，函数fn必须以future作为参数。
set_result(self, result)： 存放结果，此函数会执行回调函数。
set_exception(self, exception)：存放异常，此函数会执行回调函数。
3. ioloop的常用接口
add_future(self, future, callback)： 当future返回结果时，会将callback登记到ioloop中，由ioloop在下次轮询时调用。
add_callback(self, callback, *args, **kwargs)： 将callback登记到ioloop中，由ioloop在下次轮询时调用。
add_timeout(self, deadline, callback, *args, **kwargs)： 将callback登记到ioloop中，由ioloop在指定的deadline时间调用。
def call_at(self, when, callback, *args, **kwargs)： 将callback登记到ioloop中，由ioloop在指定的when时间调用。
def call_later(self, delay, callback, *args, **kwargs)： 将callback登记到ioloop中， 由ioloop在指定的延迟delay秒后调用。
add_handler(self, fd, handler, events)： 将文件符fd的event事件和回调函数handler登记到ioloop中，当事件发生时，触发。
4. gen.coroutine的应用
直接上官网的例子
普通的回调函数的方式：
class AsyncHandler(RequestHandler):
@asynchronous
def get(self):
http_client = AsyncHTTPClient()
http_client.fetch("http://example.com",
callback=self.on_fetch)
def on_fetch(self, response):
do_something_with_response(response)
self.render("template.html")
同步的方式：
class GenAsyncHandler(RequestHandler):
@gen.coroutine
def get(self):
http_client = AsyncHTTPClient()
response = yield http_client.fetch("http://example.com")
do_something_with_response(response)
self.render("template.html")
可以看出代码明显清晰，简单多了。如果有深层次的回调，效果会更明显。
5. gen.coroutine的源码
def coroutine(func, replace_callback=True): return _make_coroutine_wrapper(func, replace_callback=True)
接着看_make_coroutine_wrapper的源码：
def _make_coroutine_wrapper(func, replace_callback):
@functools.wraps(func)
def wrapper(*args, **kwargs):
future = TracebackFuture()
if replace_callback and 'callback' in kwargs:
callback = kwargs.pop('callback')
IOLoop.current().add_future(
future, lambda future: callback(future.result()))
try:
result = func(*args, **kwargs)
except (Return, StopIteration) as e:
result = getattr(e, 'value', None)
except Exception:
future.set_exc_info(sys.exc_info())
return future
else:
if isinstance(result, types.GeneratorType):
# Inline the first iteration of Runner.run. This lets us
# avoid the cost of creating a Runner when the coroutine
# never actually yields, which in turn allows us to
# use "optional" coroutines in critical path code without
# performance penalty for the synchronous case.
try:
orig_stack_contexts = stack_context._state.contexts
yielded = next(result)
if stack_context._state.contexts is not orig_stack_contexts:
yielded = TracebackFuture()
yielded.set_exception(
stack_context.StackContextInconsistentError(
'stack_context inconsistency (probably caused '
'by yield within a "with StackContext" block)'))
except (StopIteration, Return) as e:
future.set_result(getattr(e, 'value', None))
except Exception:
future.set_exc_info(sys.exc_info())
else:
Runner(result, future, yielded)
try:
return future
finally:
future = None
future.set_result(result)
return future
return wrapper
这段代码注意到，有几个关键地方。
future = TracebackFuture()
TracebackFuture就是Future，两者是同一个类。这里定义了future变量, 是用来后面增加callback用的。当函数执行完时，会将这个future返回。
result = func(*args, **kwargs)
这里执行被装饰的函数，返回result。我们知道有yield语句的函数，返回结果是一个生成器。
yielded = next(result)
返回yield结果， next(result)被要求返回Future，list, dict,或者YieldPoint类型，一般返回Future。
Runner(result, future, yielded)
实例化Runner，这步很重要。
return future
返回future。
6. Runner类的实现
class Runner(object): def __init__(self, gen, result_future, first_yielded): self.gen = gen self.result_future = result_future self.future = _null_future 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()
__init__构造函数首先初始化参数，然后调用handle_yield方法。
因为first_yielded为Future类型， 所以简化下handle_yield的代码。
def handle_yield(self, yielded): self.future = yielded if not self.future.done(): self.io_loop.add_future( self.future, lambda f: self.run()) return False return True
handle_yield方法，首先判断yielded是否已经返回结果，如果没有就调用io_loop.add_future方法。这样当yielded返回结果时，就会回调self.run方法。如果已经返回，就直接执行self.run方法。
self.run方法会将控制权返回给被gen.coroutine的函数。
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 try: value = future.result() except Exception: self.had_exception = True yielded = self.gen.throw(*sys.exc_info()) 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(getattr(e, 'value', None)) 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
这里注意到几个关键地方。
value = future.result()
获取yielded的结果值。
yielded = self.gen.send(value)
使用send方法将结果返回，并且将执行权交给被装饰的函数。并且返回下一个yield的值。
如果函数生成器后面没有yield语句了，就会抛出StopIteration异常。
调用set_result存储结果，返回。
self.result_future.set_result(getattr(e, 'value', None))
如果函数生成器后面还有yield语句，就会调用handle_yield，仍然登记self.run方法。
if not self.handle_yield(yielded): return
之所以要有个判断，是需要在while循环里，如果future已经有返回结果了，就继续取结果，send结果，
一直到future的结果没有返回或者没有yield语句了。