How do the GIL mechanism, thread parallel execution, and preemptive multitasking concept interact in Python?

In Python, there is a mechanism called GIL (Global Interpreter Lock), which ensures that at any given moment, only one thread executes Python bytecode. This means that even with multiple threads, parallel execution of Python code is limited.

Preemptive multitasking is a scheduling method where the operating system or interpreter automatically switches between threads without waiting for them to voluntarily yield.

In Python, threads operate with preemptive multitasking, but due to the GIL, only one thread can execute Python code at a time. This limits the efficiency of multithreaded CPU-bound tasks. However, for I/O-bound tasks, multithreading is still useful because threads can wait for input/output, freeing the GIL for other threads.

Example:

import threading
import time

def task():
    print('Start of task')
    time.sleep(1)  # releases GIL during waiting
    print('End of task')

threads = [threading.Thread(target=task) for _ in range(3)]
for t in threads:
    t.start()
for t in threads:
    t.join()

Here, threads run in parallel during waiting, despite the GIL.