tornado what is the difference between @web.asynchronous @gen.coroutine VS @gen.corutine

Question

In the document, @web.asynchronous is unnecessary if the method is also decorated with @gen.coroutine. like this

@web.asynchronous
@gen.coroutine
def get(self):
    ...

but, In document, They also explain that If you use @web.asynchronous, then you should call self.finish(). However, In above case(using two decorator together) the connection is finished with out calling "self.finish()"

I'm wondering what happened in there.

and In below case, It works different with above.

@web.asynchronous
def get(self):
    self.test()

@gen.coroutine
def test(self):
    httpClient = AsyncHttpClient()
    val = yield httpClient.fetch("http://www.google.com")
    print test
    #self.finish()

If "self.finish()" is not called the connection is not closed.

Is there anybody can explain this?

Answer 1

The secret is here:

if isinstance(result, Future):
    # If @asynchronous is used with @gen.coroutine, (but
    # not @gen.engine), we can automatically finish the
    # request when the future resolves.  Additionally,
    # the Future will swallow any exceptions so we need
    # to throw them back out to the stack context to finish
    # the request.
    def future_complete(f):
        f.result()
        if not self._finished:
            self.finish()
    IOLoop.current().add_future(result, future_complete)

@asychronous checks for the method returning a future (i.e. @gen.coroutine) and if so, adds an IOLoop callback to finish the connection when the future completes.