from tornado.httpclient import HTTPClient
from tornado.concurrent import Future
def synchronous_fetch(url):http_client = HTTPClient()def handle_response(response):callback(response.body)http_client.fetch(url,callbace=handle_response)

def async_fetch_future(url):http_client=HTTPClient()my_future=Future()fetch_future=http_client.fetch(url)fetch_future.add_done_callback(lambda f:my_future.set_result(f.result))return my_future

rom tornado import gen@gen.coroutine
def fetch_coroutine(url):http_client = AsyncHTTPClient()response = yield http_client.fetch(url)raise gen.Return(response.body)

from tornado import gen
from tornado import HTTPClient
def fetch_coroutie(url):http_client=AsyncHTTPClient() 　　respone=yield http_client.fetch(url) 

　　# raise gen.Return(respone.body) 　　　　return respone.body

async def fetch_coroutine(url):http_client = AsyncHTTPClient()response = await http_client.fetch(url)return response.body

def run(self):future=self.gen.send(self.next)def callback(f):self.next=f.result()self.run()future.add_done_callback(callback)

# The IOLoop will catch the exception and print a stack trace in
# the logs. Note that this doesn't look like a normal call, since
# we pass the function object to be called by the IOLoop.IOLoop.current().spawn_callback(divide, 1, 0)

　　协程模式　　　1，结合callbacks　　　　　　为了使用回调来代替Future与异步代码进行交互，将这个调用装在task中，这将会在你生成的Future对象中添加一个回调参数　　　　　　

@gen.coroutine
def call_task():yield gen.Task(some_function, other_args)#把yeild换成gen_Task  

　　　　　2，调用阻塞函数

　　　　　　在协程中调用阻塞函数的最简单方法是使用ThreadPoolExecutor  这将返回与协程兼容的Futures

thread_pool = ThreadPoolExecutor(4)@gen.coroutine
def call_blocking():yield thread_pool.submit(blocking_func, args)

　　　　　　3，并行

　　　　　　　　协程装饰器识别列表或者字典中的Futures，并且并行等待这些Fuures

@gen.coroutine
def parallel_fetch(url1,url2):resp1,resp2 = yield [http_client.fetch(url1),http_client.fetch(url2)]@gen.coroutine
def parallel_fetch_dict(urls):responses = yield {url: http_client.fetch(url)for url in urls}

　　　　　　4，交叉存取技术（项目一般用到比较多）

　　　　　　　　有时保存一个Future比立刻yield它更有用，你可以等待它之前执行其他操作

def get(self):fetch_future = self.fetch_next_chunk()while True:chunk = yield fetch_futureif chunk is None:breakself.write(chunk)fetch_future= self.fetch_next_chunk()yield self.flush()

　　　　　　5，循环

　　　　　　　　因为python无法使用forwhile循环yield迭代器，并且捕获yield的返回结果，相反，你需要将循环和访问结果区分开来，

import motor
db = motor.MotorClient().test@gen.coroutine
def loop_example(collection):cursor = db.collection.find()while (yield cursor.fetch_next):doc = cursor.next_object()

　　　　　　6，在后台运行

@gen.coroutine
def minute_loop():while True:yield do_something()yield gen.sleep(60)# Coroutines that loop forever are generally started with
# spawn_callback().
IOLoop.current().spawn_callback(minute_loop)

更过内容可以参考：http://tornado-zh-cn.readthedocs.io/zh_CN/latest/guide/coroutines.html#python-3-5-async-await