网址的Python Tornado异步获取

Question

In the following code example I have a function do_async_thing which appears to return a Future , even though I'm not sure why?

import tornado.ioloop
import tornado.web
import tornado.httpclient

@tornado.gen.coroutine
def do_async_thing():
    http = tornado.httpclient.AsyncHTTPClient()
    response = yield http.fetch("http://www.google.com/")
    return response.body

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        x = do_async_thing()
        print(x) # <tornado.concurrent.Future object at 0x10753a6a0>

        self.set_header("Content-Type", "application/json")
        self.write('{"foo":"bar"}')
        self.finish()

if __name__ == "__main__":
    app = tornado.web.Application([
        (r"/foo/?", MainHandler),
    ])
    app.listen(8888)

    tornado.ioloop.IOLoop.current().start()

You'll see that I yield the call to fetch and in doing so I should have forced the value to be realised (and subsequently been able to access the body field of the response).

What's more interesting is how I can even access the body field on a Future and not have it error (as far as I know a Future has no such field/property/method)

So does anyone know how I can:

1. Resolve the Future so I get the actual value
2. Modify this example so the function do_async_thing makes multiple async url fetches

Now it's worth noting that because I was still getting a Future back I thought I would try adding a yield to prefix the call to do_async_thing() (eg x = yield do_async_thing() ) but that gave me back the following error:

tornado.gen.BadYieldError: yielded unknown object <generator object get at 0x1023bc308>

I also looked at doing something like this for the second point:

def do_another_async_thing():
    http = tornado.httpclient.AsyncHTTPClient()
    a = http.fetch("http://www.google.com/")
    b = http.fetch("http://www.github.com/")
    return a, b

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        y = do_another_async_thing()
        print(y)

But again this returns:

<tornado.concurrent.Future object at 0x102b966d8>

Where as I would've expected a tuple of Futures at least? At this point I'm unable to resolve these Futures without getting an error such as:

tornado.gen.BadYieldError: yielded unknown object <generator object get at 0x1091ac360>

Update

Below is an example that works (as per answered by A. Jesse Jiryu Davis)

But I've also added another example where by I have a new function do_another_async_thing which makes two async HTTP requests (but evaluating their values are a little bit more involved as you'll see):

def do_another_async_thing():
    http = tornado.httpclient.AsyncHTTPClient()
    a = http.fetch("http://www.google.com/")
    b = http.fetch("http://www.github.com/")
    return a, b

@tornado.gen.coroutine
def do_async_thing():
    http = tornado.httpclient.AsyncHTTPClient()
    response = yield http.fetch("http://www.google.com/")
    return response.body

class MainHandler(tornado.web.RequestHandler):
    @tornado.gen.coroutine
    def get(self):
        x = yield do_async_thing()
        print(x) # displays HTML response

        fa, fb = do_another_async_thing()
        fa = yield fa
        fb = yield fb
        print(fa.body, fb.body) # displays HTML response for each

It's worth clarifying: you might expect the two yield statements for do_another_async_thing to cause a blockage. But here is a breakdown of the steps that are happening:

• do_another_async_thing returns immediately a tuple with two Futures
• we yield the first tuple which causes the program to be blocked until the value is realised
• the value is realised and so we move to the next line
• we yield again, causing the program to block until the value is realised
• but as both futures were created at the same time and run concurrently the second yield returns practically instantly

Answer 1

Coroutines return futures. To wait for the coroutine to complete, the caller must also be a coroutine, and must yield the future. So:

@gen.coroutine
def get(self):
    x = yield do_async_thing()

For more info see Refactoring Tornado Coroutines .