In Cpython, the global interpreter lock prevents multiple threads from executing python bytecode concurrently. This mechanism is implemented because it ensures that certain objects (such as a dictionary for example) cannot be concurrently accessed. There are some built-in and third-party libraries that release this lock in computationally expensive tasks like compression or hashing. 

Global Interpreter Lock (GIL)

Here is a simple example of using threads to print a string.

```python 
import threading

def f():
    print("Hello World!", threading.currentThread().getName())

if __name__ == '__main__':
    threads = [threading.Thread(target=f) for x in range(3)
    # Creates list of threads -> [Thread-1, Thread-2, Thread-3]
    for i in threads:
        i.start()
    for i in threads:
        i.join()
```

The .start() method signals the thread to begin execution. Alternatively, the .join() method signals for the thread to stop once it is done executing the function. The code above printed:
```
Hello World! Thread-1
Hello World! Thread-2
Hello World! Thread-3
```

Threading Example

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.

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

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. 

Multiprocessing 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