Skip to main content

Tornado Coroutine and Tasks

Tornado Coroutine and Tasks

Tornado is a powerful Python web framework and asynchronous networking library. In this tutorial, we will explore one of the most important concepts in Tornado: Coroutine and Tasks. Let's dive in!

Understanding Coroutine and Why It's Used​

A coroutine is a special kind of function which can pause its execution before reaching return, and it can indirectly pass control to another coroutine for some time. This is precisely what makes them perfect for handling I/O-bound tasks.

In Tornado, we use coroutines in combination with the IOLoop - the core of Tornado’s async functionality. Coroutines allow you to write asynchronous code that looks like normal, linear, blocking code. This can make your code much easier to write, read, and maintain.

Here's a simple example of a coroutine in Tornado:

from tornado import gen

@gen.coroutine
def simple_coroutine():
    print("Hello, Coroutine!")

In the example above, we used the @gen.coroutine decorator from Tornado’s gen module to turn the function simple_coroutine into a coroutine.

Tornado Tasks​

Tasks in Tornado are used to schedule coroutines in a way that allows them to run concurrently.

Let's look at a very simple example of how tasks can be used.

from tornado import gen, ioloop

async def task1():
    await gen.sleep(1)
    print('Task 1 done')

async def task2():
    await gen.sleep(2)
    print('Task 2 done')

async def main():
    await gen.multi([task1(), task2()])

if __name__ == "__main__":
    ioloop.IOLoop.current().run_sync(main)

In the example above, we define two tasks, task1 and task2. These tasks are then run concurrently using the gen.multi function in the main coroutine. The gen.multi function takes a list of futures and returns a future that resolves when all input futures are done.

How Coroutine and Tasks Work Together​

Coroutines and tasks in Tornado work together to enable asynchronous execution of code. When a coroutine yields a Future (or a Task, which is a type of Future), it means, "I'm going to wait for this Future to finish. In the meantime, go let someone else run." This is the heart of asynchronous programming in Tornado.

Best Practices​

Here are some best practices when working with coroutines and tasks in Tornado:

  • Always remember to use the @gen.coroutine decorator when defining a coroutine.
  • When you want to call a coroutine from another coroutine, use yield or await. This will make the calling coroutine pause and give control back to the event loop, which can then go on and run other tasks in the meantime.
  • When you want to run multiple coroutines concurrently, use gen.multi.

Hopefully, this tutorial has helped you understand coroutines and tasks in Tornado better. As you continue your journey learning Tornado, remember that the key to mastering it is understanding and effectively using these concepts.