🧵 Python Tutorial — Threading

Introduction 🌟

Threading allows a Python program to run multiple tasks concurrently within the same process. It is extremely useful for I/O-bound tasks such as network requests, file operations, timers, and user interaction.

Note

💡 Python threads run concurrently but share the same memory
💡 Best for I/O-bound tasks — NOT CPU-bound tasks (because of the GIL)
💡 Managed using the threading module

1. Importing the Threading Module 🧱

import_threading.py

import threading

2. Creating and Starting a Thread ▶️

basic_thread.py

import threading
import time

def greet():
    print("Hello from thread!")
    time.sleep(1)

t = threading.Thread(target=greet)
t.start()
t.join()  # wait for thread to finish

✔ target → function to run
✔ start() → launches thread
✔ join() → wait for it to finish

3. Passing Arguments to Threads 🎯

thread_args.py

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

t = threading.Thread(target=show, args=("Sathish",))
t.start()
t.join()

✔ Use args or kwargs

4. Running Multiple Threads Concurrently ⚡

multiple_threads.py

def worker(num):
    print(f"Working on task {num}")

threads = []

for i in range(5):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

✔ All threads run concurrently

5. Using Threading Class (Subclassing) 🏗️

thread_class.py

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

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

✔ Override run() for custom behavior

6. Daemon Threads 👻

A **daemon thread** runs in the background and exits when the main program ends.

daemon_thread.py

import time, threading

def task():
    while True:
        print("Background task running...")
        time.sleep(1)

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

time.sleep(3)
print("Main program ending...")

✔ Daemon threads stop automatically when the program stops

7. Thread Synchronization with Lock 🔒

Threads share memory → risk of race conditions. Use Lock to prevent unsafe simultaneous access.

lock_example.py

lock = threading.Lock()
counter = 0

def increment():
    global counter
    with lock:
        temp = counter
        temp += 1
        counter = temp

threads = []
for _ in range(1000):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(counter)

✔ with lock ensures thread-safe operations

8. Using RLock (Reentrant Lock) 🔁

Allows the same thread to acquire the lock multiple times.

rlock_example.py

rlock = threading.RLock()

def task():
    with rlock:
        with rlock:  # same thread re-enters
            print("Inside RLock")

t = threading.Thread(target=task)
t.start()
t.join()

9. Using Condition for Thread Coordination 🕹️

condition_example.py

condition = threading.Condition()
data_ready = False

def producer():
    global data_ready
    with condition:
        data_ready = True
        print("Producer: Data ready")
        condition.notify()

def consumer():
    with condition:
        condition.wait()
        print("Consumer: Received data")

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

✔ Great for producer–consumer workflow

10. Using Event for Signaling 🚦

event_example.py

event = threading.Event()

def waiter():
    print("Waiting for event...")
    event.wait()
    print("Event triggered!")

threading.Thread(target=waiter).start()

input("Press Enter to trigger event...")
event.set()

✔ Event helps coordinate threads

11. Thread Pool with concurrent.futures 💼

thread_pool.py

from concurrent.futures import ThreadPoolExecutor

def task(n):
    return n * 2

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

✔ Simplest way to manage many threads

12. GIL (Global Interpreter Lock) — Important ⚠️

Python threads cannot run **CPU-bound tasks** in parallel due to the GIL. Use threading only for:

  • ✔ I/O-bound tasks (network, disk, waiting)
  • ✔ Background tasks

Note

❌ Use multiprocessing for CPU-intensive tasks

13. Real-World Example — Downloading Files Concurrently 🌐

download_example.py

import threading, time

def download(file):
    print(f"Downloading {file}")
    time.sleep(2)
    print(f"Finished {file}")

files = ["a.jpg", "b.jpg", "c.jpg"]

threads = [threading.Thread(target=download, args=(f,)) for f in files]

for t in threads: t.start()
for t in threads: t.join()

Threading Cheat Sheet 📘

FeatureMethod / Object
Create threadThread(target=...)
Start threadstart()
Wait for threadjoin()
Daemon threaddaemon=True
SynchronizationLock(), RLock()
CoordinationEvent(), Condition()
Thread PoolThreadPoolExecutor

Best Practices 💡

  • ✔ Use threading only for I/O-bound tasks
  • ✔ Always use locks for shared resources
  • ✔ Prefer ThreadPoolExecutor for many tasks
  • ✔ Avoid long-running daemon threads
  • ✔ Use logging instead of print() in threaded apps

Conclusion 🎉

>>“Threading lets your Python programs multitask efficiently — when used with the right strategy.” ✨

You now understand Threading in Python! Want the next topic? Try Multiprocessing, AsyncIO, Concurrency Models, or GIL Explained. Just tell me! 😊