The asyncio module makes use of the keywords
```python
async
```
and
 ```python
await
```

```async``` is placed before the function declaration ```def``` and turns the function into a native coroutine or an asynchronous generator. Placing ```await``` inside an async function creates a coroutine while placing the ```yield``` keyword creates an asynchronous generator.


```await``` passes function control back to the event loop by suspending the coroutine. the ```await``` keyword in a function waits for a different function to execute and allows the main program to execute other code.

Asyncio Syntax

The built-in asyncio module is often used in I/O bound scenarios or in network related code. It allows functions to be run concurrently so that the main program does not have to wait for it to finish execution. Asyncio allows for concurrent Python coroutines, network I/O, control over subprocesses, the distribution of tasks via queues, and the synchronization of concurrent code. 

California State University, San Bernardino

Concurrency and parallelism in Python are mainly handled by 2 built-in modules: Threading and multiprocessing. Threading allows Python to make use of multiple threads in order to speed up programs that are I/O dependent. Alternatively, multiprocessing allows Python to use multiple processes to speed up CPU bound scenarios.

Additionally, web servers, databases, and distributed networks also make use of the asyncio module. Asyncio allows for concurrent code so that the aforementioned systems don't have wait on execution

Concurrency and Paralellism in Python

The threading module is a built-in library that allows Python to use multiple threads to handle I/O bound tasks. This module also includes functions for thread management and execution. Unfortunately, CPython has something called a global interpreter lock (GIL) which forces only one thread to execute code at a time.

Threading Module

Python's built-in multiprocessing module allows for spawning of processes for local and remote concurrency. The multiprocessing module bypasses the global interpreter lock (see the Threading Module node for more info) by implementing the subprocesses. This allows the utilization of multiple cores on a CPU. 

Learn Before

Related

Learn After