https://www.geeksforgeeks.org/what-is-the-python-global-interpreter-lock-gil/

GIL Reference

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. 

California State University, San Bernardino

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

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
```

Learn Before

Related

Learn After