How does the GIL mechanism limit the parallel execution of threads in the Python interpreter?

GIL (Global Interpreter Lock) is a mechanism in the CPython interpreter that ensures only one thread executes Python bytecode at any given time.

This limitation is due to many internal Python structures not being thread-safe, and GIL prevents concurrent access to them from different threads.

Because of GIL, multithreaded Python programs cannot efficiently utilize multiple CPU cores for parallel execution of Python code. Threads may switch, but only one Python thread actually executes.

However, GIL does not block I/O operations or calls in C extensions that can release the GIL, allowing other threads to run.

Example:

import threading
import time

def worker():
    for _ in range(5):
        print("Working")
        time.sleep(1)

threads = []
for i in range(3):
    t = threading.Thread(target=worker)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

Despite having multiple threads, due to GIL, they do not run in parallel on multiple cores for CPU-intensive tasks.