Python Threading — Thread Class, start() vs run(), and Concurrent Programming Explained

The Story That Explains Threads 🍽️Threads समझाने वाली कहानी 🍽️一个讲清线程的故事 🍽️

A process is a running program with its own memory. A thread is one line of execution inside a process. Every process has at least one thread — the main thread. Extra threads let one process juggle several tasks. In standard CPython only one thread runs Python code at a time; Python switches between them very often, so from the outside they look like they run together.

Process अपनी memory वाला एक चलता हुआ program है। Thread process के अंदर execution की एक धारा है। हर process में कम से कम एक thread होता है — main thread। अतिरिक्त threads से एक process कई काम सँभालता है। Standard CPython में एक समय में सिर्फ़ एक thread Python code चलाता है; Python उनके बीच बहुत जल्दी-जल्दी बदलता है, इसलिए बाहर से लगता है कि वे साथ चल रहे हैं।

进程 是一个拥有独立内存的运行中的程序。线程 是进程内部的一条执行路线。每个进程至少有一个线程 — 主线程。增加线程可以让一个进程同时应付多个任务。在标准的 CPython 中，同一时刻只有一个线程在执行 Python 代码；Python 在它们之间切换得非常频繁，所以从外面看它们像是在同时运行。

Single-Threaded vs Multi-Threaded — The Visual Difference ⏱️Single-Threaded बनाम Multi-Threaded — दिखने वाला फ़र्क़ ⏱️单线程 vs 多线程 — 直观的差别 ⏱️

⏱️ Simulator: Sequential vs Threads⏱️ Simulator: Sequential बनाम Threads⏱️ 模拟器：顺序 vs 线程

The same three tasks (A, B, C), run one after another and then in three threads. Choose I/O (each task sleeps — like waiting for a server) or CPU (each task does pure math). The bars are real start and end times from runs on our test machine.

वही तीन काम (A, B, C), पहले एक के बाद एक और फिर तीन threads में। I/O (हर काम sleep करता है — जैसे server का इंतज़ार) या CPU (हर काम सिर्फ़ गणित करता है) चुनिए। Bars हमारी test machine पर runs के असली शुरू और ख़त्म होने के समय हैं।

同样的三个任务（A、B、C），先依次运行，再放进三个线程运行。选择 I/O（每个任务都 sleep — 就像等待服务器）或 CPU（每个任务只做数学计算）。条形图是我们测试机上真实运行时记录的开始和结束时间。

_thread Module vs threading Module 🧰_thread Module बनाम threading Module 🧰_thread 模块 vs threading 模块 🧰

Python ships with two threading APIs. Knowing why matters — you will meet both in old code and in interview questions.

Python में दो threading APIs हैं। इसका कारण जानना ज़रूरी है — दोनों आपको पुराने code और interview सवालों में मिलेंगे।

Python 自带两套线程 API。了解其中原因很重要 — 你会在旧代码和面试题中遇到这两者。

# --- The old _thread way (avoid) ---
import _thread, time

def worker(name):
    print(f"{name} started")
    time.sleep(1)
    print(f"{name} done")

_thread.start_new_thread(worker, ("t1",))
time.sleep(2)      # have to sleep - no join() available

# --- The modern threading way (use this) ---
import threading, time

def worker(name):
    print(f"{name} started")
    time.sleep(1)
    print(f"{name} done")

t = threading.Thread(target=worker, args=("t1",), name="worker-1")
t.start()
t.join()           # proper synchronization

Creating Your First Thread 🚀अपना पहला Thread बनाना 🚀创建你的第一个线程 🚀

The simplest way: pass a target function to threading.Thread, then call .start(). Python creates a new OS thread, that thread calls your function, and control comes back to the main thread straight away.

सबसे आसान तरीक़ा: threading.Thread को एक target function दीजिए, फिर .start() बुलाइए। Python एक नया OS thread बनाता है, वह thread आपका function बुलाता है, और नियंत्रण तुरंत main thread पर लौट आता है।

最简单的方法：把一个 target 函数传给 threading.Thread，然后调用 .start()。Python 会创建一个新的操作系统线程，由它来调用你的函数，而控制权立即回到主线程。

import threading, time

def count_down(name, n):
    for i in range(n, 0, -1):
        print(f"{name}: {i}")
        time.sleep(1)
    print(f"{name}: BLAST OFF!")

# Create two threads that run concurrently
t1 = threading.Thread(target=count_down, args=("Rocket-A", 3))
t2 = threading.Thread(target=count_down, args=("Rocket-B", 3))

t1.start()                 # begins concurrently
t2.start()                 # begins concurrently
t1.join()                  # wait for t1 to finish
t2.join()                  # wait for t2 to finish
print("Both rockets launched.")

The Thread Class — Constructor and Attributes 🧩Thread Class — Constructor और Attributes 🧩Thread 类 — 构造参数与属性 🧩

import threading, time

def work(seconds):
    time.sleep(seconds)

t = threading.Thread(target=work, args=(2,), name="io-worker-01")

print(f"name:       {t.name}")
print(f"alive?      {t.is_alive()}")    # False - not started
print(f"ident:      {t.ident}")         # None - not started

t.start()
print(f"alive?      {t.is_alive()}")    # True
print(f"ident:      {t.ident}")         # now an integer
print(f"native_id:  {t.native_id}")     # kernel thread id

t.join()
print(f"alive?      {t.is_alive()}")    # False - finished

start() vs run() — The Critical Difference ⚠️start() बनाम run() — सबसे ज़रूरी फ़र्क़ ⚠️start() vs run() — 关键区别 ⚠️

This is the most misunderstood thing in Python threading. Both methods exist and both call your target — but only start() creates a new thread. Mixing them up silently kills your concurrency.

Python threading में यही सबसे ज़्यादा ग़लत समझी जाने वाली बात है। दोनों methods हैं और दोनों आपका target बुलाते हैं — पर सिर्फ़ start() नया thread बनाता है। इन्हें मिला देने से आपकी concurrency चुपचाप ख़त्म हो जाती है।

这是 Python 多线程中最常被误解的一点。两个方法都存在，也都会调用你的 target — 但只有 start() 会创建 新线程。把它们搞混会悄悄地扼杀并发。

import threading, time

def slow_task():
    print(f"  [{threading.current_thread().name}] working...")
    time.sleep(2)
    print(f"  [{threading.current_thread().name}] done")

# === CORRECT: use start() ===
print("--- with start() ---")
start_time = time.time()
threads = [threading.Thread(target=slow_task, name=f"t{i}") for i in range(3)]
for t in threads: t.start()
for t in threads: t.join()
print(f"took {time.time() - start_time:.1f}s")

# === WRONG: use run() ===
print("\n--- with run() ---")
start_time = time.time()
threads = [threading.Thread(target=slow_task, name=f"t{i}") for i in range(3)]
for t in threads: t.run()       # NO new threads created!
print(f"took {time.time() - start_time:.1f}s")

🔀 Simulator: start() vs run()🔀 Simulator: start() बनाम run()🔀 模拟器：start() vs run()

Three threads, each sleeping 0.5 s. See which thread really runs each task, and how long it all takes. The timeline was recorded from a real run.

तीन threads, हर एक 0.5 s sleep करता है। देखिए हर काम असल में कौन-सा thread चलाता है, और सब में कितना समय लगता है। Timeline असली run से रिकॉर्ड की गई है।

三个线程，每个 sleep 0.5 秒。看看每个任务究竟由哪个线程运行，以及总共花了多长时间。时间线来自真实运行的记录。

Passing Arguments — args and kwargs 📦Arguments देना — args और kwargs 📦传递参数 — args 与 kwargs 📦

Pass positional arguments as a tuple to args= and keyword arguments as a dict to kwargs=. Remember the trailing comma for a single argument: args=("only",), not args=("only").

Positional arguments को tuple के रूप में args= में और keyword arguments को dict के रूप में kwargs= में दीजिए। एक argument के लिए आख़िरी comma याद रखिए: args=("only",), args=("only") नहीं।

位置参数以 元组 形式传给 args=，关键字参数以 字典 形式传给 kwargs=。只有一个参数时别忘了末尾的逗号：args=("only",)，而不是 args=("only")。

import threading, time

def download(url, timeout, retries=3, verbose=False):
    if verbose:
        print(f"GET {url} (timeout={timeout}s, retries={retries})")
    time.sleep(0.5)
    return f"done: {url}"

# Positional args as a tuple, keyword args as a dict
t = threading.Thread(
    target=download,
    args=("https://api.example.com", 10),        # url, timeout
    kwargs={"retries": 5, "verbose": True}
)
t.start()
t.join()

The trailing-comma bug, run for realआख़िरी comma वाला bug, असल में चलाकर末尾逗号的 bug，真实运行

import threading

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

# Bug: ("Mohit") is just a string, not a tuple
t = threading.Thread(target=greet, args=("Mohit"))
t.start()
t.join()
print("main: still running - the error happened inside the thread")

# Fix: the trailing comma makes a 1-tuple
t = threading.Thread(target=greet, args=("Mohit",))
t.start()
t.join()

Subclassing Thread — The Class-Based Way 🏭Thread को Subclass करना — Class वाला तरीक़ा 🏭继承 Thread — 基于类的写法 🏭

When your thread needs its own state, helper methods or a clear identity, subclass Thread and override run(). This is the object-oriented alternative to passing a function.

जब आपके thread को अपनी state, helper methods या साफ़ पहचान चाहिए, तो Thread को subclass कीजिए और run() override कीजिए। Function देने का यह object-oriented विकल्प है।

当线程需要自己的状态、辅助方法或清晰的身份时，就继承 Thread 并重写 run()。这是传入函数之外的面向对象写法。

import threading, time

class Downloader(threading.Thread):
    def __init__(self, url, retries=3):
        super().__init__(name=f"dl-{url[-6:]}")    # call parent init!
        self.url = url
        self.retries = retries
        self.result = None                          # place to store output
        self.error = None

    def run(self):                                  # override run()
        try:
            print(f"[{self.name}] fetching...")
            time.sleep(1)                           # pretend it's a real request
            self.result = f"<html of {self.url}>"
        except Exception as e:
            self.error = e

# Use it exactly like a Thread
urls = ["example.com/a", "example.com/b", "example.com/c"]
workers = [Downloader(u) for u in urls]
for w in workers: w.start()           # start(), never run()
for w in workers: w.join()

for w in workers:
    if w.error:
        print(f"{w.name} FAILED: {w.error}")
    else:
        print(f"{w.name} -> {w.result}")

import threading

class Worker(threading.Thread):
    def __init__(self, job):
        self.job = job              # forgot super().__init__()

    def run(self):
        print("working on", self.job)

try:
    Worker("report").start()
except RuntimeError as e:
    print("RuntimeError:", e)

Function vs Class — When to Use Which ⚖️Function बनाम Class — कब कौन-सा ⚖️函数 vs 类 — 何时用哪个 ⚖️

The Thread Life Cycle 🔄Thread का जीवन-चक्र 🔄线程的生命周期 🔄

🔄 Simulator: Lifecycle Lab🔄 Simulator: Lifecycle Lab🔄 模拟器：生命周期实验室

Drive one thread through its life. The worker waits on an Event, so you decide when it finishes. Try join() before start(), or start() twice. Every output was checked against Python on 250 random sequences.

एक thread को उसके जीवन से गुज़ारिए। Worker एक Event का इंतज़ार करता है, इसलिए वह कब ख़त्म हो यह आप तय करते हैं। start() से पहले join(), या दो बार start() आज़माइए। हर output 250 random sequences पर Python से जाँचा गया।

带领一个线程走完它的一生。工作线程在等待一个 Event，所以由 你 决定它何时结束。试试在 start() 之前调用 join()，或者调用两次 start()。每个输出都已在 250 个随机序列上与 Python 核对。

join() — Waiting for Threads to Finish ⏳join() — Threads के ख़त्म होने का इंतज़ार ⏳join() — 等待线程结束 ⏳

join() is the most important method for controlling threaded programs. It is how one thread (usually main) says: "pause me here until that other thread has finished". Without join(), the main thread can race ahead — even exit — before the workers are done.

Threaded programs को नियंत्रित करने का सबसे ज़रूरी method join() है। इसी से एक thread (आमतौर पर main) कहता है: "मुझे यहाँ रोको जब तक वह दूसरा thread ख़त्म न हो"। join() के बिना main thread workers के ख़त्म होने से पहले आगे भाग सकता है — बाहर भी निकल सकता है।

join() 是控制多线程程序最重要的方法。一个线程（通常是主线程）就是用它说："在这里暂停我，直到那个线程完成"。没有 join()，主线程可能在工作线程完成之前就跑到前面 — 甚至退出。

Why join() exists — what happens without itjoin() क्यों है — इसके बिना क्या होता हैjoin() 为什么存在 — 没有它会怎样

import threading, time

def worker():
    print("worker: starting")
    time.sleep(2)
    print("worker: finished")

print("main: launching thread")
t = threading.Thread(target=worker)
t.start()
# NO join() - main thread races ahead
print("main: done")

main: done was printed while the worker was still sleeping. In a bigger script, main might use results the worker has not produced yet, or close files it is still writing.

Worker के अभी sleep करते हुए ही main: done print हो गया। बड़ी script में main ऐसे नतीजे इस्तेमाल कर सकता है जो worker ने अभी बनाए ही नहीं, या ऐसी files बंद कर सकता है जिन्हें worker अभी लिख रहा है।

工作线程还在 sleep 时，main: done 就已经打印出来了。在更大的脚本里，主线程可能会使用工作线程还没生成的结果，或关闭它还在写入的文件。

import threading, time

def worker():
    print("worker: starting")
    time.sleep(2)
    print("worker: finished")

print("main: launching thread")
t = threading.Thread(target=worker)
t.start()
t.join()                     # wait here until worker is done
print("main: done")

join(timeout=N) — wait only so longjoin(timeout=N) — बस इतना इंतज़ारjoin(timeout=N) — 只等这么久

import threading, time

def very_slow_task():
    time.sleep(10)
    print("task finished after 10s")

t = threading.Thread(target=very_slow_task)
t.start()

print("main: waiting up to 3 seconds...")
t.join(timeout=3)                 # give up after 3s
if t.is_alive():
    print("main: worker still running - moving on without it")
else:
    print("main: worker finished on time")
print("main: continuing with other work")

⏳ Simulator: join(timeout) Lab⏳ Simulator: join(timeout) Lab⏳ 模拟器：join(timeout) 实验室

Pick how long the worker takes and the timeout. See how long main really waits and what is_alive() says afterwards. Checked against 35 real runs (run at 1/5 speed).

चुनिए worker कितना समय लेता है और timeout कितना है। देखिए main असल में कितना इंतज़ार करता है और बाद में is_alive() क्या कहता है। 35 असली runs से जाँचा गया (1/5 गति पर चलाए)।

选择工作线程需要多长时间以及超时时间。看看主线程实际等了多久，之后 is_alive() 返回什么。已与 35 次真实运行核对（以 1/5 速度运行）。

Joining many threads — the right patternकई threads join करना — सही pattern等待多个线程 — 正确写法

for t in threads:
    t.start()
    t.join()   # blocks here!

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

import threading, time

def task(n):
    time.sleep(2)
    print(f"task {n} done")

threads = [threading.Thread(target=task, args=(i,)) for i in range(5)]

# === WRONG - start & join in the same loop ===
start = time.time()
for t in threads:
    t.start()
    t.join()                  # blocks before the next thread starts
print(f"wrong way: {time.time() - start:.1f}s")

# === RIGHT - separate loops ===
threads = [threading.Thread(target=task, args=(i,)) for i in range(5)]
start = time.time()
for t in threads: t.start()   # fire them all off first
for t in threads: t.join()    # then wait for all
print(f"right way: {time.time() - start:.1f}s")

🔁 Simulator: Loop Patterns🔁 Simulator: Loop Patterns🔁 模拟器：循环写法

Choose how many threads (each sleeps 0.4 s) and which loop pattern. The bars are real start and end times.

कितने threads (हर एक 0.4 s sleep करता है) और कौन-सा loop pattern, यह चुनिए। Bars असली शुरू और ख़त्म होने के समय हैं।

选择线程数量（每个 sleep 0.4 秒）和循环写法。条形图是真实的开始和结束时间。

Collecting results after join()join() के बाद नतीजे जमा करना在 join() 之后收集结果

import threading, time

class SumWorker(threading.Thread):
    def __init__(self, numbers):
        super().__init__()
        self.numbers = numbers
        self.result = None

    def run(self):
        time.sleep(1)                     # simulate work
        self.result = sum(self.numbers)

# Split the work across 3 workers
w1 = SumWorker([1, 2, 3, 4, 5])
w2 = SumWorker([6, 7, 8, 9, 10])
w3 = SumWorker([11, 12, 13, 14, 15])

for w in (w1, w2, w3): w.start()
for w in (w1, w2, w3): w.join()     # AFTER this line, results are ready

total = w1.result + w2.result + w3.result
print(f"partials: {w1.result}, {w2.result}, {w3.result}")
print(f"total:    {total}")

A thread can be started only onceThread सिर्फ़ एक बार start हो सकता है线程只能启动一次

import threading, time

t = threading.Thread(target=lambda: time.sleep(1))
t.start()
t.join()                               # wait for it to finish
print(f"alive after join?  {t.is_alive()}")    # False

try:
    t.start()                          # try to reuse
except RuntimeError as e:
    print(f"error: {e}")

# You can, however, call join() as many times as you like
t.join()                               # safe - returns immediately
t.join()                               # also safe
print("multiple joins on a finished thread: OK")

Never join() a thread from itselfThread को उसी के अंदर से join() मत कीजिए不要在线程内部 join() 自己

A thread joining itself would wait for itself for ever. Python catches this and raises RuntimeError:

ख़ुद को join करने वाला thread अपना ही इंतज़ार हमेशा करता रहता। Python इसे पकड़कर RuntimeError raise करता है:

一个线程 join 自己，就会永远等待自己。Python 会捕获这种情况并抛出 RuntimeError：

import threading

def bad_worker():
    # current_thread() returns the Thread object we're inside
    me = threading.current_thread()
    try:
        me.join()                      # waiting for myself - nonsense!
    except RuntimeError as e:
        print(f"caught: {e}")

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

join() returns Nonejoin() None लौटाता हैjoin() 返回 None

import threading

def compute():
    return 42                          # this return value is DROPPED

t = threading.Thread(target=compute)
t.start()
result = t.join()                      # join returns None, not 42
print(f"join returned: {result}")      # None
print("to capture the return value, use a subclass or a shared container")

Practical example — parallel file processing with progressकाम का example — progress के साथ parallel file processing实用示例 — 带进度显示的并行文件处理

import threading, time, random

random.seed(7)                          # same sizes on every run

class FileProcessor(threading.Thread):
    def __init__(self, filename):
        super().__init__(name=f"proc-{filename}")
        self.filename = filename
        self.bytes_read = 0
        self.size = random.randint(1, 4)    # pretend file size in MB

    def run(self):
        time.sleep(self.size)               # pretend it takes 1 s per MB
        self.bytes_read = self.size * 1024 * 1024

# Kick off 5 workers
files = ["log01.txt", "log02.txt", "log03.txt", "log04.txt", "log05.txt"]
workers = [FileProcessor(f) for f in files]
start = time.time()
for w in workers: w.start()

# Poll with short join timeouts to show live progress
while any(w.is_alive() for w in workers):
    for w in workers:
        w.join(timeout=0.5)                 # wait up to 0.5 s per worker
    still_running = sum(1 for w in workers if w.is_alive())
    print(f"[{time.time() - start:3.1f}s] {len(workers) - still_running}/{len(workers)} finished")

# All done - safe to read results
print("\n=== Summary ===")
for w in workers:
    print(f"{w.filename}: {w.bytes_read / 1024 / 1024:.1f} MB")

join() cheat sheetjoin() cheat sheetjoin() 速查表

Bug Doctor, Golden Rules and Quiz 🏆Bug Doctor, सुनहरे नियम और Quiz 🏆Bug 医生、黄金法则与小测验 🏆

🩺 Simulator: Bug Doctor🩺 Simulator: Bug Doctor🩺 模拟器：Bug 医生

Six real threading mistakes from this tutorial. Buggy code on the left, fixed code on the right, changed lines marked. Every output is from a real run.

इस tutorial की छह असली threading ग़लतियाँ। बाईं ओर buggy code, दाईं ओर ठीक किया हुआ, बदली lines चिह्नित। हर output असली run से है।

本教程中的六个真实多线程错误。左边是有 bug 的代码，右边是修正后的代码，改动的行已标出。每个输出都来自真实运行。

Quick Quiz — 8 Questionsछोटा Quiz — 8 सवाल小测验 — 8 道题