{"id":4124,"date":"2022-07-18T01:02:46","date_gmt":"2022-07-18T01:02:46","guid":{"rendered":"https:\/\/www.pythontutorial.net\/?page_id=4124"},"modified":"2025-04-02T06:56:34","modified_gmt":"2025-04-02T06:56:34","slug":"python-asyncio-create_task","status":"publish","type":"page","link":"https:\/\/www.pythontutorial.net\/python-concurrency\/python-asyncio-create_task\/","title":{"rendered":"Python asyncio.create_task()"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn how to use asyncio.create_task()<\/code> function to run multiple tasks concurrently.<\/p>\n\n\n\n

Simulating a long-running operation #<\/a><\/h2>\n\n\n\n

To simulate a long-running operation, you can use the sleep()<\/code><\/code> coroutine of the asyncio<\/code> package. The sleep()<\/code><\/code> function delays a specified number of the second:<\/p>\n\n\n

await<\/span> asyncio.sleep(seconds)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
import<\/span> asyncio\n\n\nasync<\/span> def<\/span> call_api<\/span>(message, result=1000<\/span>, delay=3<\/span>)<\/span>:<\/span>\n    print(message)\n    await<\/span> asyncio.sleep(delay)\n    return<\/span> result<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The call_api()<\/code> is a coroutine. It displays a message, pauses a specified number of seconds (default to three seconds), and returns a result.<\/p>\n\n\n\n
The following program uses the call_api()<\/code> twice and measures the time it takes to complete:<\/p>\n\n\n
import<\/span> asyncio\nimport<\/span> time\n\n\nasync<\/span> def<\/span> call_api<\/span>(message, result=1000<\/span>, delay=3<\/span>)<\/span>:<\/span>\n    print(message)\n    await<\/span> asyncio.sleep(delay)\n    return<\/span> result\n\n\nasync<\/span> def<\/span> main<\/span>()<\/span>:<\/span>\n    start = time.perf_counter()\n\n    price = await<\/span> call_api('Get stock price of GOOG...'<\/span>, 300<\/span>)\n    print(price)\n\n    price = await<\/span> call_api('Get stock price of APPL...'<\/span>, 400<\/span>)\n    print(price)\n\n    end = time.perf_counter()\n    print(f'It took {round(end-start,0<\/span>)}<\/span> second(s) to complete.'<\/span>)\n\nasyncio.run(main())<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Get stock price of GOOG...\n300<\/span>\nGet stock price of APPL...\n400<\/span>\nIt took 6.0<\/span> second(s) to complete.<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works (focusing on the main()<\/code> coroutine):<\/p>\n\n\n\n
First, start a timer to measure the time using the perf_counter()<\/code> function of the time<\/code> module:<\/p>\n\n\n
 start = time.perf_counter()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Second, call the call_api()<\/code> coroutine and display the result:<\/p>\n\n\n
price = await<\/span> call_api('Get stock price of GOOG...'<\/span>, 300<\/span>)\nprint(price)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Third, call the call_api()<\/code> a second time:<\/p>\n\n\n
price = await<\/span> call_api('Get stock price of APPL...'<\/span>, 400<\/span>)\nprint(price)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Finally, show the time the program takes to complete:<\/p>\n\n\n
end = time.perf_counter()\nprint(f'It took {round(end-start,0<\/span>)}<\/span> second(s) to complete.'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Since each call_api()<\/code> takes three seconds, and calling it twice takes six seconds.<\/p>\n\n\n\n
In this example, we call a coroutine directly and don’t put it on the event loop to run. Instead, we get a coroutine object and use the await<\/code> keyword to execute it and get a result.<\/p>\n\n\n\n
The following picture illustrates the execution flow of the program:<\/p>\n\n\n
\n
\"Python<\/figure>\n<\/div>\n\n\n
In other words, we use async<\/code> and await<\/code> to write asynchronous code but can’t run it concurrently. To run multiple operations concurrently, we’ll need to use something called tasks.<\/p>\n\n\n\n
Introduction to Python tasks #<\/a><\/h2>\n\n\n\n
A task is a wrapper of a coroutine that schedules the coroutine to run on the event loop as soon as possible.<\/p>\n\n\n\n
The scheduling and execution occur in a non-blocking manner. In other words, you can create a task and execute other code instantly while the task is running.<\/p>\n\n\n\n
Notice that the task is different from the await<\/code> keyword that blocks the entire coroutine until the operation completes with a result.<\/p>\n\n\n\n
It’s important that you can create multiple tasks and schedule them to run instantly on the event loop at the same time. <\/p>\n\n\n\n
To create a task, you pass a coroutine to the create_task()<\/code><\/code> function of the asyncio<\/code> package. The create_task()<\/code><\/code> function returns a Task<\/code> object.<\/p>\n\n\n\n
The following program illustrates how to create two tasks that schedule and execute the call_api()<\/code> coroutine:<\/p>\n\n\n
import<\/span> asyncio\nimport<\/span> time\n\n\nasync<\/span> def<\/span> call_api<\/span>(message, result=1000<\/span>, delay=3<\/span>)<\/span>:<\/span>\n    print(message)\n    await<\/span> asyncio.sleep(delay)\n    return<\/span> result\n\n\nasync<\/span> def<\/span> main<\/span>()<\/span>:<\/span>\n    start = time.perf_counter()\n\n    task_1 = asyncio.create_task(\n        call_api('Get stock price of GOOG...'<\/span>, 300<\/span>)\n    )\n\n    task_2 = asyncio.create_task(\n        call_api('Get stock price of APPL...'<\/span>, 300<\/span>)\n    )\n\n    price = await<\/span> task_1\n    print(price)\n\n    price = await<\/span> task_2\n    print(price)\n\n    end = time.perf_counter()\n    print(f'It took {round(end-start,0<\/span>)}<\/span> second(s) to complete.'<\/span>)\n\n\nasyncio.run(main())<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Get stock price of GOOG...\nGet stock price of APPL...\n300<\/span>\n300<\/span>\nIt took 3.0<\/span> second(s) to complete.<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, start a timer:<\/p>\n\n\n
start = time.perf_counter()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Next, create a task and schedule it to run on the event loop immediately:<\/p>\n\n\n
task_1 = asyncio.create_task(\n   call_api('Get stock price of GOOG...'<\/span>, 300<\/span>)\n)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Then, create another task and schedule it to run on the event loop immediately:<\/p>\n\n\n
task_2 = asyncio.create_task(\n    call_api('Get stock price of APPL...'<\/span>, 400<\/span>)\n)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
After that, wait for the tasks to be completed:<\/p>\n\n\n
price = await<\/span> task_1\nprint(price)\n\nprice = await<\/span> task_2\nprint(price)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
It’s important to use the await<\/code> keyword to wait for the tasks at some point in the program. <\/p>\n\n\n\n
If we did not use the await<\/code> keyword, Python would schedule the task to run but stopped it when the asyncio.run()<\/code> shutdown the event loop.<\/p>\n\n\n\n
The following picture illustrates the execution flow of the program:<\/p>\n\n\n\n
\"Python<\/figure>\n\n\n\n
Finally, show the time it takes to complete the main()<\/code> function:<\/p>\n\n\n
end = time.perf_counter()\nprint(f'It took {round(end-start,0<\/span>)}<\/span> second(s) to complete.'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
By using the create_task()<\/code> function, the program is much faster. The more tasks you run, the faster it is.<\/p>\n\n\n\n
Running other tasks while waiting #<\/a><\/h2>\n\n\n\n
When the call_api<\/code> is running, you can run other tasks. For example, the following program displays a message every second while waiting for the call_api<\/code> tasks:<\/p>\n\n\n
import<\/span> asyncio\nimport<\/span> time\n\n\nasync<\/span> def<\/span> call_api<\/span>(message, result=1000<\/span>, delay=3<\/span>)<\/span>:<\/span>\n    print(message)\n    await<\/span> asyncio.sleep(delay)\n    return<\/span> result\n\n\nasync<\/span> def<\/span> show_message<\/span>()<\/span>:<\/span>\n    for<\/span> _ in<\/span> range(3<\/span>):\n        await<\/span> asyncio.sleep(1<\/span>)\n        print('API call is in progress...'<\/span>)\n\n\nasync<\/span> def<\/span> main<\/span>()<\/span>:<\/span>\n    start = time.perf_counter()\n\n    message_task = asyncio.create_task(\n        show_message()\n    )\n\n    task_1 = asyncio.create_task(\n        call_api('Get stock price of GOOG...'<\/span>, 300<\/span>)\n    )\n\n    task_2 = asyncio.create_task(\n        call_api('Get stock price of APPL...'<\/span>, 300<\/span>)\n    )\n\n    price = await<\/span> task_1\n    print(price)\n\n    price = await<\/span> task_2\n    print(price)\n\n    await<\/span> message_task\n\n    end = time.perf_counter()\n    print(f'It took {round(end-start,0<\/span>)}<\/span> second(s) to complete.'<\/span>)\n\n\nasyncio.run(main())<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Get stock price of GOOG...\nGet stock price of APPL...\nAPI call is<\/span> in<\/span> progress...\nAPI call is<\/span> in<\/span> progress...\n300<\/span>\n300<\/span>\nAPI call is<\/span> in<\/span> progress...\nIt took 3.0<\/span> second(s) to complete.<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The following picture illustrates the execution flow:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Summary #<\/a><\/h2>\n\n\n\n
    \n
  • A task is a wrapper of a coroutine that schedules the coroutine to run on the event loop as soon as possible.<\/li>\n\n\n\n
  • Use the create_task()<\/code> function of the asyncio<\/code> library to create a task.<\/li>\n\n\n\n
  • Use the await<\/code> keyword with the task at some point in the program so that the task can be completed before the event loop is closed by the asyncio.run()<\/code> function.<\/li>\n<\/ul>\n
    \n\t
    \n\t\t
    Was this tutorial helpful ?<\/div>\n\t\t
    \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t
Because sleep()<\/code><\/code> is a coroutine, you need to use the await<\/a><\/code> keyword. For example, the following uses the sleep()<\/code><\/code> coroutine to simulate an API call:<\/p>\n\n\n