How to create and run asynchronous tasks in Python

1. What is an asynchronous task

Asynchronous task is an object that schedules and runs an asyncio coroutine independently. It provides a handle to the dispatched coroutine that asyncio programs can query and use to interact with the coroutine.

Tasks are created from coroutines. It takes a coroutine object, wraps the coroutine, schedules it for execution, and provides methods to interact with it. Tasks are executed independently. This means that it is scheduled in the asyncio event loop and will execute regardless of what happens in the coroutine that created it. This is different from executing the coroutine directly, where the caller must wait for it to complete.

The asyncio.Task class extends the asyncio.Future class, an instance is awaitable. Future is a lower-level class that represents the result that will eventually arrive. Classes that extend the Future class are often called Future-like.

Because asynchronous tasks are awaitable, this means that the coroutine can use await expressions to wait for the task to complete.

...
# wait for a task to be done
await task

Now that we know what an asyncio task is, let’s see how to create one.

2. How to create a task

Create a task using the provided coroutine instance. Recall that a coroutine is defined using an async def expression and looks like a function.

# define a coroutine
async def task_coroutine():
	# ...

Tasks can only be created and scheduled in coroutines. There are two main ways to create and schedule tasks, they are:

• Create tasks using high-level API (preferred)

• Create tasks using low-level API

2.1. Advanced API

You can use the asyncio.create_task() function to create tasks. The asyncio.create_task() function accepts a coroutine instance and an optional task name, and returns an asyncio.Task instance.

...
# create a coroutine
coro = task_coroutine()
# create a task from a coroutine
task = asyncio.create_task(coro)

This can be achieved by using a compound statement in a single line.

...
# create a task from a coroutine
task = asyncio.create_task(task_coroutine())

This will do a few things:

• Wrap the coroutine in an asynchronous task instance.

• Scheduling tasks to be executed in the current event loop.

• Return a task instance

Task instances can be discarded, interacted with through methods, and waited on by coroutines. This is the preferred way to create tasks from coroutines in asyncio programs.

2.2. Low-level API

You can also use the lower-level asyncio API to create tasks from coroutines.

The first method is to use the asyncio.ensure_future() function. This function takes a task, future, or future-like object such as a coroutine, and optionally a loop for scheduling it. If no loop is provided, it will be scheduled in the current event loop.

If a coroutine is provided for this function, it will be wrapped in an instance for us and then returned.

...
# create and schedule the task
task = asyncio.ensure_future(task_coroutine())

Another low-level function we can use to create and schedule tasks is the loop.create_task() method. This function requires access to a specific event loop where the coroutine is executed as a task.

We can get the instance of the current event loop in the asyncio program through the asyncio.get_event_loop() function. This can then be used to call the create_task() method to create a Task instance and schedule it for execution.

...
# get the current event loop
loop = asyncio.get_event_loop()
# create and schedule the task
task = loop.create_task(task_coroutine())

3. When does the task run?

A common question after creating a task is when will it run?

Although we can schedule the coroutine to run independently as a task through the create_task() function, it may not run immediately. In fact, the task won't execute until the event loop has a chance to run.

This will not happen until all other coroutines are not running and it is the task's turn to run.

For example, if we have an asyncio program with a coroutine that creates and schedules tasks, the scheduled tasks will not run until the calling coroutine that created the task is suspended.

This may occur if the calling coroutine chooses to sleep, chooses to wait for another coroutine or task, or chooses to wait for a new task that has been scheduled.

...
# create a task from a coroutine
task = asyncio.create_task(task_coroutine())
# await the task, allowing it to run
await task

Now we know what tasks are and how to schedule them.

The above is the detailed content of How to create and run asynchronous tasks in Python. For more information, please follow other related articles on the PHP Chinese website!