What is GIL (Global Interpreter Lock) in Python…

GIL (Global Interpreter Lock) is a mechanism in the CPython interpreter that allows only one thread to execute at a time. Even on multi-core processors, GIL prevents threads from truly parallelizing Python code execution.

Reasons for the existence of GIL:

Simplification of memory management: GIL simplifies thread-safe memory management and garbage collection (reference counting). Without GIL, more complex and resource-intensive locking mechanisms would be required to protect shared data structures.
Maintaining compatibility with C libraries: GIL facilitates integration with existing C libraries that may not be thread-safe.

Impact of GIL:

Limiting CPU-bound task parallelism: For CPU-intensive tasks, GIL becomes a bottleneck, as execution does not parallelize across cores even on multi-core systems. Threads have to wait for GIL to be released.
Less impact on I/O-bound tasks: For tasks that involve intensive input/output (network requests, file operations), GIL is less critical. During I/O wait times, threads release GIL, allowing others to run.

Ways to bypass GIL:

Multiprocessing: Instead of threads, independent processes are used. Each process has its own Python interpreter instance and GIL. Processes can run in parallel on different cores.
Asynchronous programming (asyncio): Uses an asynchronous I/O model on a single thread. Instead of creating many threads, async code switches between tasks during I/O waits. GIL has less impact here, as there is no parallel CPU-bound execution.
C/C++ libraries: Code written in C or C++ can perform operations without holding GIL, releasing it during execution. Popular libraries like NumPy and SciPy use this for high-performance computations.

# Example of GIL impact on CPU-bound task
import threading
import time

def cpu_bound_task():
    count = 0
    for i in range(10**7):
        count += 1

# Creating two threads for CPU-bound task
t1 = threading.Thread(target=cpu_bound_task)
t2 = threading.Thread(target=cpu_bound_task)

start_time = time.time()
t1.start()
t2.start()
t1.join()
t2.join()
end_time = time.time()

print(f"Execution time with threads (CPU-bound): {end_time - start_time:.2f} seconds") # Time will be roughly twice as long as a single task due to GIL

# Example of I/O-bound task where GIL is less noticeable
import threading
import time

def io_bound_task():
    time.sleep(1) # Simulate I/O wait

# Creating two threads for I/O-bound task
t1 = threading.Thread(target=io_bound_task)
t2 = threading.Thread(target=io_bound_task)

start_time = time.time()
t1.start()
t2.start()
t1.join()
t2.join()
end_time = time.time()

print(f"Execution time with threads (I/O-bound): {end_time - start_time:.2f} seconds") # Time will be about 1 second, as threads release GIL during sleep

What is GIL (Global Interpreter Lock) in Python?