Python AsyncIO

Ref: https://realpython.com/async-io-python/

• Threading Vs Multi-Processing
• Threading is better for I/O based tasks
• Multi-Processing is better for CPU based tasks
• What’s important to know about threading is that it’s better for IO-bound tasks.
• Concurrency Vs Parallelism
• Concurrency is when two tasks can start, run, and complete in overlapping time periods. e.g., Threading, AsyncIO
• Parallelism is when tasks literally run at the same time, eg. multi-processing. 
• While a CPU-bound task is characterised by the computer’s cores continually working hard from start to finish, an IO-bound job is dominated by a lot of waiting on input/output to complete.
• Preemptive multitasking Vs Cooperative multitasking
• OS preempts a thread forcing it to give up the use of CPU (E.g., Threading)
• Cooperative multitasking on the other hand, the running process voluntarily gives up the CPU to other processes E.g., (AsyncIO)
• Coroutine Vs Method/Function/Subroutine
• Method or Function returns a value and don't remember the state between invocations
• A coroutine is a special function that can give up control to its caller without losing its state
• Coroutine Vs Generator
• Generator yield back value to invoker
• Coroutine yields control to another coroutine and can resume execution from point it gave the control
• A generator can't accept arguments once it is started where as a coroutine can accept arguments once it started
• AsyncIO is a single-threaded, single-process design: it uses cooperative multitasking
• AsyncIO gives a feeling of concurrency despite using a single thread in a single process
• Coroutines (a central feature of async IO) can be scheduled concurrently, but they are not inherently concurrent.
• Asynchronous routines are able to “pause” while waiting on their ultimate result and let other routines run in the meantime.

import asyncio

import time

async def count_func():

    print("Line One")

    await asyncio.sleep(1) # await non-blocking call

    print("Line Two")

async def main():

    await asyncio.gather(count_func(), count_func(), count_func())

if __name__ == "__main__":

    t1 = time.time()

    asyncio.run(main())

    elapsed = time.time() - t1

    #This is supposed to take more than 3 secs

    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

Output:

#####

Line One

Line One

Line One

Line Two

Line Two

Line Two

main.py executed in 1.10 seconds.