CODEWITHSUNDEEP
python-3.xpython-asyncio
Gandalf
Gandalf

Reputation: 13683

Visualizing asyncio coroutines execution

I am trying to understand how async coroutine are executed start to finish. Lets say i have this function

async def statemachine(state):

that does the following:

  1. Read value on remote server
  2. Write to remote mysql server
  3. Write to local redis server
  4. Delete a record from a remote mysql server
  5. Create event and notify coroutine execution has finished

Since async suspends execution to give other coroutines time to execute, will the execution always start from step 1 to step 5 always.

Upvotes: 3

Views: 1687

Answers (1)

Charming Robot
Charming Robot

Reputation: 2660

A coroutine is always executed sequentially. Many (co)routines however can (co)operate together while being supervised by an event-loop or a scheduler of sorts.

So if you stack all your tasks in one coroutine e.g.:

async def statemachine(state):
    await read_value_on_remote_server()
    await write_to_remote_mysql_server()
    await write_to_local_redis_server()
    await delete_a_record_from_a_remote_mysql_server()
    await create_event_and_notify_coroutine_execution_has_finished()

your statemachine will await each task one by one until they're done. This scenario isn't really useful, and doesn't provide any benefit over sync code.

A scenario where async execution shines is, let's say you have a web app that schedules one statemachine coroutine per user request. Now whenever a user hits your server with a request, a new coroutine is scheduled in the eventloop. And because the event loop can only run one thing at a time (pseudo concurrency), it will let each coroutine execute (let's assume using a round-robin algorithm) until they suspend, because they're awaiting an object or another coroutine that is awaiting another object.

The way a coroutine suspends is by having an await statement. This lets the event loop know that the coroutine is awaiting an operation that isn't necessarily CPU bound. e.g. network call or user input.

Thankfully, we're shielded from the details of the implementation of the eventloop and how it manages to know when a coroutine should be resumed. This is typically done using a library like Python's stdlib select https://docs.python.org/2/library/select.html.

For most use cases, you should know that a coroutine always executes sequentially and that the event-loop is what manages the execution of coroutines by using co-operative methods (unlike a typical OS scheduler for example).

If you want to run several coroutines pseudo-concurrently, you can look at asycio.gather or the more correct asyncio.create_task. Hope this helps.

Upvotes: 4

Related Questions