Multithreading in Python

 

Learning Sections          show

Multithreading in Python

Multithreading is a programming technique used to run multiple threads (smaller units of process) concurrently within a single process. It allows for parallel execution of tasks and can significantly improve the performance of applications, especially those involving I/O-bound operations.

---

Creating Threads

You can create and start a new thread by using the threading module in Python:

import threading

def print_numbers():
    for i in range(10):
        print(i)

t1 = threading.Thread(target=print_numbers)
t1.start()
t1.join()  # Wait for the thread to complete

---

Using Thread Pools

The concurrent.futures module provides a high-level interface for asynchronously executing callables. The ThreadPoolExecutor is particularly useful for managing a pool of threads:

from concurrent.futures import ThreadPoolExecutor

def task(n):
    print(n * "Hello ")

with ThreadPoolExecutor(3) as executor:
    executor.map(task, range(5))

---

Thread Synchronization

Threads often need to communicate and share data. Python provides several primitives to handle synchronization, such as locks, events, conditions, and semaphores:

import threading

lock = threading.Lock()

def safe_print(msg):
    with lock:
        print(msg)

t1 = threading.Thread(target=safe_print, args=("Hello from Thread 1",))
t2 = threading.Thread(target=safe_print, args=("Hello from Thread 2",))

t1.start()
t2.start()
t1.join()
t2.join()

---

Using Queues

The queue module provides a thread-safe FIFO implementation that can be used to safely pass data between threads:

import queue
import threading

q = queue.Queue()

def producer():
    for i in range(5):
        q.put(i)
        print("Produced", i)

def consumer():
    while not q.empty():
        item = q.get()
        print("Consumed", item)

t1 = threading.Thread(target=producer)
t2 = threading.Thread(target=consumer)

t1.start()
t2.start()
t1.join()
t2.join()

---

Daemon Threads

Daemon threads run in the background and are automatically terminated when all non-daemon threads have completed. They are useful for background tasks that should not block the program from exiting:

import threading
import time

def background_task():
    while True:
        print("Running in the background")
        time.sleep(2)

t = threading.Thread(target=background_task)
t.daemon = True
t.start()

print("Main thread exiting")