Here is a simple example of using multiple processes to print a string.
```python
import multiprocessing

def f():
    print("Hello World!", multiprocessing.current_process())

if __name__ == '__main__':
    processes = [multiprocessing.Process(target=f) for x in range(3)]
    # Creates list of processes -> [proc-1, proc-2, proc-3]
    for i in processes:
        i.start()
    for i in processes:
        i.join()
```
The .start() method signals the process to begin execution. Alternatively, the .join() method signals for the process to stop once it is done executing the function. The code above printed:
```
Hello World! <Process name='Process-2' parent=15444 started>
Hello World! <Process name='Process-1' parent=15444 started>
Hello World! <Process name='Process-3' parent=15444 started>
```

Multiprocessing Example

Python's built-in multiprocessing module spawns separate processes for concurrency. Using separate processes avoids the CPython global interpreter lock limitation described for threads, allowing CPU-bound work to use multiple CPU cores.

California State University, San Bernardino

Google

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

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. 

Learn Before

Related

Learn After