On Wed, Oct 3, 2012 at 7:04 AM, Ben Darnell <b...@bendarnell.com> wrote:
> Your async_callback version doesn't actually work - it never calls
> callback_sleep.  async_callback is meant to be used as a wrapper to
> deal with exception handling - it was necessary in early versions of
> Tornado, but not any more.  You probably meant io_loop.add_callback
> instead of async_callback, but if you make that change you'll see that
> time.sleep blocks in that version as well.

> @asynchronous is a declaration, not a directive:  it describes the
> fact that get() is asynchronous (i.e. there is more work to be done
> after it returns), it doesn't make it so.  Tornado's core is still a
> single-threaded event loop, so to achieve concurrency within a single
> process you need to use or make non-blocking versions of any
> time-consuming functions you use (e.g.  IOLoop.add_timeout instead of
> time.sleep, or AsyncHTTPClient instead of HTTPClient or urllib), or
> hand that work off to another thread or process.

> -Ben

> On Tue, Oct 2, 2012 at 8:57 PM, Jimmy <li.jiam...@gmail.com> wrote:
> > I don't mean to make it sleep. You can assume the sleep to some heavy
> load
> > work, like loop i from 0 to 10000000000. When multiple requests come in
> > concurrently, I saw the request is executed in sequence, not in parallel
> > (using yield gen.Task). But the old way of async_callback works.

> > How to use gen.Task to create async behavior?

> > On Wednesday, October 3, 2012 5:51:54 AM UTC+8, aliane abdelouahab wrote:

> >> look here, maybe it will help:

> http://groups.google.com/group/python-tornado/browse_thread/thread/ae...

> >> On 2 oct, 11:08, Li jiaming <li.jiam...@gmail.com> wrote:
> >> > I created a simple app with gen.task. But seems doesn't work
> >> > asynchronously. I try to call /sleep for multiple times, but it
> handles
> >> > request in sequence.

> >> > import tornado.ioloop
> >> > import tornado.web
> >> > from tornado.web import asynchronous
> >> > from tornado import gen
> >> > import time
> >> > import tornado.httpserver

> >> > class MainHandler(tornado.web.RequestHandler):
> >> >     def get(self):
> >> >         print 'receive root request'
> >> >         self.write("Hello, world")

> >> > class SleepHandler(tornado.web.RequestHandler):
> >> >     @asynchronous
> >> >     @gen.engine
> >> >     def get(self):
> >> >         print 'receive sleep request'
> >> >         yield [ gen.Task(self.sleep, 10),
> >> >                 gen.Task(self.sleep, 9)]
> >> >         self.write("Wake up")
> >> >         self.finish()

> >> >     def sleep(self, sec, callback):
> >> >         print 'sleep for %d seconds' % sec
> >> >         time.sleep(sec)
> >> >         print 'finish sleep %d' % sec
> >> >         return callback()

> >> > application = tornado.web.Application([
> >> >     (r"/", MainHandler),
> >> >     (r"/sleep", SleepHandler),
> >> > ])

> >> > if __name__ == "__main__":
> >> >     server = tornado.httpserver.HTTPServer(application)
> >> >     server.listen(8888)
> >> >     tornado.ioloop.IOLoop.instance().start()

> >> > *Anything wrong in my code?*

> >> > I also tried async_callback (which is claimed to be obsoleted way of
> >> > doing
> >> > async). But it works. It can handle multiple requests in parallel when
> >> > calling /sleep.

> >> > class SleepHandler(tornado.web.RequestHandler):
> >> >     @asynchronous
> >> >     def get(self):
> >> >         print 'receive sleep request'
> >> >         self.async_callback(self.callback_sleep, 10)

> >> >     def callback_sleep(self, sec):
> >> >         print 'callback sleep for %d seconds' % sec
> >> >         time.sleep(sec)
> >> >         print 'finish callback sleep for %d seconds' % sec
> >> >         self.write('wake up')
> >> >         self.finish()