Python Interview Questions

Multithreading is a concurrent execution model that allows multiple threads to be created within a process, enabling multiple tasks to be executed simultaneously. Each thread runs independently but shares the same memory space, which can lead to efficient utilization of resources, especially on multi-core systems. Threads are often used to perform background tasks, improve performance, and enhance responsiveness in applications.

Achieving Multithreading in Python

In Python, multithreading is achieved using the threading module, which provides a high-level interface for creating and managing threads. However, due to the Global Interpreter Lock (GIL), Python threads are not truly concurrent on CPU-bound tasks. They are more suitable for I/O-bound tasks where the program spends a lot of time waiting for external resources.

Key Components of the threading Module

1. Thread Class: Used to create and manage individual threads.
2. Lock Class: Provides a mechanism to synchronize threads and prevent race conditions.
3. Event Class: Used for signaling between threads.
4. Semaphore Class: Manages a counter that allows a limited number of threads to access a resource.
5. Condition Class: Provides a more advanced mechanism for thread synchronization.

Creating and Starting Threads

Example: Basic Thread Creation

import threading
import time

def print_numbers():
    for i in range(5):
        print(i)
        time.sleep(1)

# Create a thread
thread = threading.Thread(target=print_numbers)

# Start the thread
thread.start()

# Wait for the thread to complete
thread.join()

print("Thread has finished executing")

In this example:

• A thread is created with the target function print_numbers.
• The thread is started using the start() method.
• The join() method is used to wait for the thread to complete before moving on.

Using Lock to Synchronize Threads

When multiple threads access shared resources, it can lead to race conditions. Locks are used to synchronize threads and prevent these conditions.

Example: Using Lock

import threading

counter = 0
lock = threading.Lock()

def increment_counter():
    global counter
    for _ in range(100000):
        lock.acquire()
        counter += 1
        lock.release()

# Create multiple threads
threads = []
for _ in range(10):
    thread = threading.Thread(target=increment_counter)
    threads.append(thread)
    thread.start()

# Wait for all threads to complete
for thread in threads:
    thread.join()

print(f"Final counter value: {counter}")

In this example:

• A global counter is incremented by multiple threads.
• A Lock is used to ensure that only one thread can increment the counter at a time, preventing race conditions.

Using Thread Subclass

You can also create a custom thread by subclassing threading.Thread and overriding the run() method.

Example: Subclassing Thread

import threading
import time

class MyThread(threading.Thread):
    def run(self):
        for i in range(5):
            print(f"Thread {self.name} is running: {i}")
            time.sleep(1)

# Create and start threads
threads = [MyThread() for _ in range(3)]
for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

print("All threads have finished executing")

In this example:

• A custom thread class MyThread is created by subclassing threading.Thread.
• The run() method is overridden to define the thread's behavior.

Using Queue for Thread Communication

The queue module can be used to safely share data between threads.

Example: Using Queue

import threading
import queue

def worker(q):
    while True:
        item = q.get()
        if item is None:
            break
        print(f"Processing item {item}")
        q.task_done()

q = queue.Queue()

# Create worker threads
threads = []
for _ in range(4):
    thread = threading.Thread(target=worker, args=(q,))
    thread.start()
    threads.append(thread)

# Enqueue items
for item in range(10):
    q.put(item)

# Block until all items are processed
q.join()

# Stop workers
for _ in range(4):
    q.put(None)
for thread in threads:
    thread.join()

print("All tasks have been processed")

In this example:

• A queue is used to pass items to worker threads.
• Worker threads process items from the queue.
• None is used as a sentinel value to signal the workers to stop.

Summary

• Multithreading: Allows multiple threads to run concurrently within a single process.
• GIL: Python's Global Interpreter Lock affects true concurrency for CPU-bound tasks but not I/O-bound tasks.
• threading Module: Provides tools to create and manage threads, locks, events, semaphores, and conditions.
• Synchronization: Use locks to prevent race conditions when accessing shared resources.
• Custom Threads: Create custom thread classes by subclassing threading.Thread.
• Communication: Use queue for safe communication between threads.

Multithreading can improve the performance of I/O-bound tasks and enhance the responsiveness of applications by allowing multiple operations to proceed concurrently.