Python Multithreading – Create, Sync, and Communicate Threads

Introduction – Why Use Multithreading in Python?

Python is known for its simplicity and readability, but did you know it also supports multithreading?

Multithreading is a powerful way to:

• Run multiple tasks concurrently
• Optimize I/O-bound operations
• Build responsive applications (e.g., GUI, network services)

Even with Python’s Global Interpreter Lock (GIL), multithreading is ideal for I/O-bound tasks like file I/O, network calls, or database operations.

In this guide, you’ll learn:

• Thread lifecycle in Python
• Creating, starting, joining threads
• Main thread, daemon threads, thread priorities
• Thread pools for scalable parallelism
• Synchronization, deadlocks, and inter-thread communication

Thread Lifecycle in Python

A Python thread goes through several states:

Python threads are managed by the OS scheduler; Python doesn’t expose all states explicitly.

Create / Start / Join Threads

Creating a Thread with threading.Thread

import threading

def task():
    print("Thread is running")

t = threading.Thread(target=task)
t.start()   # Starts the thread
t.join()    # Waits for the thread to finish

Use join() to synchronize the main thread with the child thread.

Thread with Arguments

def greet(name):
    print(f"Hello {name}")

t = threading.Thread(target=greet, args=("Alice",))
t.start()
t.join()

Using Subclassing

class MyThread(threading.Thread):
    def run(self):
        print("Thread via subclass")

t = MyThread()
t.start()
t.join()

Thread Pools with concurrent.futures

Managing many threads manually is hard. Thread pools offer a higher-level abstraction.

from concurrent.futures import ThreadPoolExecutor

def square(n):
    return n * n

with ThreadPoolExecutor(max_workers=3) as executor:
    results = executor.map(square, [1, 2, 3, 4])
    print(list(results))

Output:

[1, 4, 9, 16]

Ideal for batch processing, parallel tasks, and web scraping.

Main Thread / Daemon / Priority

Main Thread

import threading

print("Main thread:", threading.current_thread().name)

Python automatically starts a main thread when your program begins.

Daemon Threads

Daemon threads run in the background and automatically terminate when the main program exits.

def background_task():
    while True:
        print("Running in background")

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

Daemons are great for logging, heartbeat monitors, and cleanups.

⏫ Thread Priority

Python’s threading module does not support priority control directly. Thread scheduling is left to the OS.

If you need more control, consider multiprocessing or external libraries like psutil.

Synchronization and Deadlocks

Without synchronization, race conditions can occur when multiple threads modify shared data.

Using threading.Lock

lock = threading.Lock()
counter = 0

def safe_increment():
    global counter
    for _ in range(100000):
        with lock:
            counter += 1

Deadlock Example

lock1 = threading.Lock()
lock2 = threading.Lock()

def thread1():
    with lock1:
        with lock2:
            print("Thread1 acquired both locks")

def thread2():
    with lock2:
        with lock1:
            print("Thread2 acquired both locks")

These two threads could deadlock by waiting for each other’s lock.

Avoid nested locks or use threading.RLock() when needed.

Inter-thread Communication

Python threads share memory. Common communication tools include:

Shared Variables with Lock

queue = []

def producer():
    with lock:
        queue.append("data")

def consumer():
    with lock:
        if queue:
            print(queue.pop(0))

queue.Queue for Thread-safe Messaging

import queue

q = queue.Queue()

def producer():
    q.put("message")

def consumer():
    msg = q.get()
    print("Received:", msg)

threading.Thread(target=producer).start()
threading.Thread(target=consumer).start()

queue.Queue is thread-safe and handles blocking automatically.

Best Practices for Python Multithreading

Summary – Recap & Next Steps

Python multithreading lets you build concurrent, responsive, and efficient applications—especially for I/O-bound tasks.

Key Takeaways:

• Use threading.Thread or ThreadPoolExecutor for concurrent tasks
• Understand the thread lifecycle: create → start → run → terminate
• Use locks and queues for synchronization and communication
• Daemon threads die with the main program; regular threads don’t
• Deadlocks can occur—always design thread-safe logic

Real-World Relevance:
Used in web scrapers, network services, chat apps, logging systems, and asynchronous I/O operations.

FAQ – Python Multithreading

Can Python use multiple threads for CPU-bound tasks?

No. Due to the GIL, use multiprocessing for CPU-bound operations.

What is the difference between threading and multiprocessing?

• threading = shared memory, ideal for I/O-bound tasks
• multiprocessing = separate memory, ideal for CPU-bound tasks

What is a daemon thread?

A background thread that automatically terminates when the main program exits.

Can threads share data?

Yes. Threads share memory, but access must be synchronized.

What is the safest way to communicate between threads?

Use queue.Queue – it’s thread-safe and handles locking internally.