create_task() function of asyncio module in Python

The create_task() function wraps a Python coroutine as an asyncio.Task. These task instances are executed in the asyncio event loop.

Asyncio Updated 4 May 2022 3 min read

Overview

  • The asyncio module of Python enables executing coroutines through Tasks and Futures.
  • A coroutine is expected to be suspended several times as it yields the CPU, while waiting for an awaitable object to do some processing.
  • To execute a single coroutine or multiple coroutines several times, a programmer can not code all of the start/resume sequence(suspend is taken care by the coroutine itself) line by line. Instead, a loop can execute them. asyncio offers this loop, which is called an event loop that executes the coroutines through Task objects.
  • The computations done by a coroutine are abstracted as a Task in the asyncio.
  • The create_task() function of the asyncio module creates and returns a Task from a coroutine. These Task instances are executed by the event loop provided by the Python's asyncio module.
  • It is required to have an event loop created before calling create_task(). The Task is created and executed on this event loop.
  • The asyncio module allows custom event loops to be used for the task execution.

Example

python
# Example Python program that executes

            # coroutines as Tasks using the

            # event loop provided by the asyncio

            import asyncio

# A list of messages

            msgs         = []

# A list of new messages

            newmsgs     = []

# Source file

            fileOb      = open("./Tokens1.txt")

# Target file

            wfileOb      = open("./NewTokens.txt","w")

# Coroutine that reads messages from

            # a file and appends to a Python list

            async def readMessages(file, msgcol):

                while(True):

                    msg = file.readline()

                    if not msg:

                        break

                    else:

                        msgcol.append(msg)

                        #print("R:%s"%msg)

                        # Make the coroutine to yield

                        await asyncio.sleep(0)

# Coroutine that transforms messages

            # and appends to another Python list

            async def transformMessages(msgcol, nmsgcol):

                while(len(msgcol) > 0):

                    msg = msgcol.pop()

                    nmsg = msg.encode(encoding="ascii")

                    nmsgcol.append(nmsg)

                    #print("T:%s"%nmsg)

                    # coroutine yielding the CPU

                    await asyncio.sleep(0)

# Coroutine that reads the transformed

            # messages from the list and writes to a file

            async def writeMessages(nfile, nmsgcol):

                while(len(nmsgcol) > 0):

                    #print("NewMessage Count:%d"%len(nmsgcol))

                    nmsg = nmsgcol.pop()

                    nfile.write(nmsg.decode())

                    # coroutine yields after every write

                    await asyncio.sleep(0)

        #print("W:%s"%nmsg)

# A coroutine that creates tasks and waits on them

            async def main():

                t1 = asyncio.create_task(readMessages(fileOb, msgs))

                t2 = asyncio.create_task(transformMessages(msgs, newmsgs))

                t3 = asyncio.create_task(writeMessages(wfileOb, newmsgs))

                # Run mutiple asyncio.Task instances

                await asyncio.wait([t1,t2,t3])

# Create a new event loop and make it to run the tasks

            loop = asyncio.new_event_loop()

            asyncio.set_event_loop(loop)

# Now run the tasks(in the event loop)

            asyncio.run(main())

Output

Output
a1

b1

c1

d1