Python Daemon Threads, Synchronization, Lock & RLock — Safe Concurrent Programming

The Story That Explains Synchronization 📝Synchronization समझाने वाली कहानी 📝一个讲清同步的故事 📝

This tutorial covers two everyday tools for safe threading: daemon threads (background helpers that stop when the program exits) and the two lock types — Lock and RLock — that stop threads from corrupting shared data.

यह tutorial सुरक्षित threading के दो रोज़ के औज़ार बताता है: daemon threads (background सहायक जो program ख़त्म होने पर रुक जाते हैं) और दो तरह के locks — Lock और RLock — जो threads को साझा data बिगाड़ने से रोकते हैं।

本教程介绍安全多线程的两类常用工具：守护线程（daemon threads）（程序退出时随之停止的后台助手），以及两种锁 — Lock 和 RLock — 它们能防止线程破坏共享数据。

Daemon Threads — Background Helpers That Stop at Exit 👻Daemon Threads — Exit पर रुकने वाले Background सहायक 👻守护线程 — 程序退出时随之停止的后台助手 👻

Every thread is either a non-daemon thread (the default) or a daemon thread. The difference only shows when the program shuts down:

हर thread या तो non-daemon thread (default) है या daemon thread। फ़र्क़ सिर्फ़ program बंद होते समय दिखता है:

每个线程要么是 非守护 线程（默认），要么是 守护 线程。区别只在程序关闭时才显现：

Creating a daemon threadDaemon thread बनाना创建守护线程

import threading, time

def background_monitor():
    # Infinite loop - would never let a non-daemon program exit
    while True:
        time.sleep(1)
        print("[monitor] heartbeat")

# Way 1: set in the constructor (recommended)
mon = threading.Thread(target=background_monitor, daemon=True)

# Way 2: set the attribute BEFORE start()
# mon = threading.Thread(target=background_monitor)
# mon.daemon = True

mon.start()
time.sleep(3.5)
print("main exiting - daemon monitor dies automatically")

import threading, time

t = threading.Thread(target=time.sleep, args=(1,))
t.start()
try:
    t.daemon = True              # too late!
except RuntimeError as e:
    print("RuntimeError:", e)
t.join()

Classic example — the daemon is stopped before it finishesClassic example — daemon ख़त्म होने से पहले रोका गया经典示例 — 守护线程在完成前被停止

One non-daemon thread sleeps 3 seconds; one daemon thread sleeps 4 seconds. The program ends as soon as the non-daemon finishes, so the daemon never prints its exit message:

एक non-daemon thread 3 seconds sleep करता है; एक daemon thread 4 seconds। Non-daemon के ख़त्म होते ही program ख़त्म हो जाता है, इसलिए daemon अपना exit message कभी print नहीं करता:

一个非守护线程 sleep 3 秒，一个守护线程 sleep 4 秒。非守护线程一结束，程序就结束了，所以守护线程永远打印不出它的退出消息：

from threading import Thread
import time

def non_d():
    print("Non daemon enters")
    time.sleep(3)                # will finish at t = 3 s
    print("nonDaemon exits")

def d():
    print("daemon enters")
    time.sleep(4)                # would finish at t = 4 s... but is killed at 3 s
    print("Daemon exits")        # NEVER prints

nd = Thread(target=non_d)
nd.start()
d1 = Thread(target=d)
d1.setDaemon(True)               # old-style setter (deprecated)
d1.start()

👻 Simulator: Daemon Timeline👻 Simulator: Daemon Timeline👻 模拟器：守护线程时间线

Choose how long the non-daemon and the daemon sleep. The program exits when the non-daemon finishes; a daemon still sleeping at that moment is cut off. All 16 combinations were run for real (at 1/4 speed).

चुनिए non-daemon और daemon कितना sleep करें। Non-daemon ख़त्म होने पर program exit करता है; उस पल sleep कर रहा daemon बीच में कट जाता है। सभी 16 combinations असल में चलाए गए (1/4 गति पर)।

选择非守护线程和守护线程各 sleep 多久。非守护线程结束时程序退出；那时仍在 sleep 的守护线程会被中途切断。全部 16 种组合都真实运行过（以 1/4 速度）。

Try this variation — reverse the timesयह बदलाव आज़माइए — समय उलटिए试试这个变化 — 把时间反过来

from threading import Thread
import time

def non_d():
    print("Non daemon enters")
    time.sleep(4)                # now the LONGER one
    print("nonDaemon exits")

def d():
    print("daemon enters")
    time.sleep(3)                # now the SHORTER one
    print("Daemon exits")        # now it DOES print

nd = Thread(target=non_d); nd.start()
d1 = Thread(target=d); d1.daemon = True; d1.start()

The danger of daemon threads — no clean shutdownDaemon threads का ख़तरा — साफ़ shutdown नहीं守护线程的危险 — 没有干净的关闭

import threading, time

def important_writer():
    try:
        with open("data.txt", "w") as f:
            for i in range(100):
                f.write(f"line {i}\n")
                time.sleep(0.05)          # pretend slow disk
        print("wrote all 100 lines")
    finally:
        print("cleanup ran")              # never printed for a killed daemon

# Marked as daemon -> main exits mid-write
t = threading.Thread(target=important_writer, daemon=True)
t.start()
time.sleep(1)                             # about 20 lines written so far
print("main done - daemon writer gets KILLED mid-write")

The Race Condition Problem 🏁Race Condition की समस्या 🏁竞态条件问题 🏁

Before locks, let us see the problem they solve. A race condition happens when two or more threads read-modify-write the same value and the way their steps interleave produces a wrong result.

Locks से पहले, वह समस्या देखते हैं जिसे वे हल करते हैं। Race condition तब होती है जब दो या ज़्यादा threads एक ही value को read-modify-write करते हैं और उनके क़दमों के आपस में मिलने से ग़लत नतीजा आता है।

在介绍锁之前，先看看它们要解决的问题。当两个或更多线程对同一个值进行"读-改-写"，而它们的步骤交错执行导致结果错误时，就发生了 竞态条件。

Race condition demo — 10 threads × 100,000 incrementsRace condition demo — 10 threads × 100,000 increments竞态条件演示 — 10 个线程 × 100,000 次自增

import threading

counter = 0

def increment():
    global counter
    for _ in range(100_000):
        counter += 1              # NOT atomic!

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

print(f"expected: {10 * 100_000}")
print(f"got:      {counter}")
print(f"lost:     {10 * 100_000 - counter} increments")

import threading, time

counter = 0

def increment():
    global counter
    for _ in range(1_000):
        value = counter           # 1) read
        time.sleep(0)             #    let another thread run here
        counter = value + 1       # 2) add 1  3) write back

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

print(f"expected: {10 * 1_000}")
print(f"got:      {counter}")
print(f"lost:     {10 * 1_000 - counter} increments")

👣 Simulator: Race Stepper👣 Simulator: Race Stepper👣 模拟器：竞态单步演示

You are the scheduler. Each thread wants to add 1 to counter twice, in three steps (read, add, write). Click which thread runs the next step and try to lose an update. Then turn the lock on: a thread that tries to acquire() while the other holds the lock is blocked.

आप scheduler हैं। हर thread counter में दो बार 1 जोड़ना चाहता है, तीन क़दमों में (read, add, write)। Click करके चुनिए अगला क़दम कौन-सा thread चलाए और एक update खोने की कोशिश कीजिए। फिर lock चालू कीजिए: दूसरे के lock पकड़े रहते acquire() करने वाला thread रुक जाता है।

你就是调度器。每个线程想给 counter 加两次 1，每次分三步（读、加、写）。点击选择由哪个线程执行下一步，试着让一次更新丢失。然后打开锁：当另一个线程持有锁时，尝试 acquire() 的线程会被阻塞。

📊 Simulator: Race Lab — real counts📊 Simulator: Race Lab — असली गिनती📊 模拟器：竞态实验室 — 真实计数

Each program was run five times on Python 3.13. Green bars hit the expected total; red bars lost updates.

हर program Python 3.13 पर पाँच बार चलाया गया। हरी bars अपेक्षित कुल तक पहुँचीं; लाल bars ने updates खोए।

每个程序都在 Python 3.13 上运行了五次。绿色条达到了预期总数；红色条丢失了更新。

Lock — The Turn-Taking Token 🔒Lock — बारी वाला Token 🔒Lock — 轮流令牌 🔒

threading.Lock is Python's most basic synchronization tool. It has two states — unlocked and locked — and two operations — acquire() and release(). Only one thread can hold the lock at a time. Any other thread that calls acquire() sleeps until the holder calls release().

threading.Lock Python का सबसे बुनियादी synchronization औज़ार है। इसकी दो states हैं — unlocked और locked — और दो operations — acquire() और release()। एक समय पर सिर्फ़ एक thread lock रख सकता है। acquire() बुलाने वाला कोई और thread तब तक सोता है जब तक रखने वाला release() न बुलाए।

threading.Lock 是 Python 最基本的同步工具。它有两种状态 — 未锁定 和 已锁定 — 以及两个操作 — acquire() 和 release()。同一时刻只有一个线程能持有锁。其他调用 acquire() 的线程会休眠，直到持有者调用 release()。

Fixing the race conditionRace condition ठीक करना修复竞态条件

Here is the "gap" program from Section 03, which lost about 90% of its updates. We add a lock around the read-modify-write and change nothing else:

यह Section 03 वाला "gap" program है, जिसने लगभग 90% updates खोए थे। हम read-modify-write के चारों ओर lock लगाते हैं और कुछ और नहीं बदलते:

这是第 03 节中丢失了约 90% 更新的"间隙"程序。我们在读-改-写周围加一把锁，其他什么都不改：

import threading, time

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(1_000):
        lock.acquire()            # wait if someone else holds it
        value = counter
        time.sleep(0)             # the same "risky" gap as before
        counter = value + 1       # now safe - we're alone
        lock.release()            # let the next thread in

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

print(f"expected: {10 * 1_000}")
print(f"got:      {counter}")

The right way — the with statementसही तरीक़ा — with statement正确做法 — with 语句

Calling acquire() and release() by hand is fragile. If the code between them raises an exception, release() never runs, the lock stays locked for ever, and every other thread waits for ever. The with statement calls acquire() on entry and guarantees release() on exit — even on an exception.

acquire() और release() हाथ से बुलाना नाज़ुक है। अगर उनके बीच का code exception raise करे, तो release() कभी नहीं चलता, lock हमेशा के लिए locked रहता है, और बाक़ी हर thread हमेशा इंतज़ार करता है। with statement अंदर जाते समय acquire() बुलाता है और बाहर निकलते समय release() की गारंटी देता है — exception पर भी।

手动调用 acquire() 和 release() 很脆弱。如果两者之间的代码抛出异常，release() 就永远不会运行，锁会一直保持锁定，其他所有线程都会永远等待。with 语句在进入时调用 acquire()，并在退出时 保证 调用 release() — 即使发生异常也一样。

lock.acquire()
risky_operation()   # may raise
lock.release()      # never runs on an exception!

with lock:
    risky_operation()

import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100_000):
        with lock:                # acquires on enter, releases on exit
            counter += 1          # exception-safe

threads = [threading.Thread(target=increment) for _ in range(10)]
for t in threads: t.start()
for t in threads: t.join()
print(f"counter = {counter}")

Lock methods referenceLock methods referenceLock 方法速查

Non-blocking acquire — skip instead of waitNon-blocking acquire — इंतज़ार की जगह छोड़ दें非阻塞获取 — 跳过而不是等待

import threading, time

lock = threading.Lock()

def try_get_lock(worker_id):
    if lock.acquire(blocking=False):
        try:
            print(f"worker {worker_id} got the lock, working...")
            time.sleep(1)
        finally:
            lock.release()
    else:
        print(f"worker {worker_id} could not get lock - skipping")

threads = [threading.Thread(target=try_get_lock, args=(i,)) for i in range(4)]
for t in threads: t.start()
for t in threads: t.join()

Worker 0 took the lock and held it for 1 second. Workers 1–3 tried a split second later, got False at once, and moved on instead of waiting. Note the try/finally: once you acquire by hand, you must release in finally.

Worker 0 ने lock लिया और 1 second रखा। Workers 1–3 ने पल भर बाद कोशिश की, तुरंत False पाया, और इंतज़ार करने की जगह आगे बढ़ गए। try/finally देखिए: हाथ से acquire करने पर release finally में ही करना चाहिए।

Worker 0 拿到锁并持有 1 秒。Worker 1–3 稍后一瞬间尝试，立刻得到 False，于是继续往下走而不是等待。注意 try/finally：一旦手动获取，就必须在 finally 中释放。

Deadlock — When Locks Attack 💀Deadlock — जब Locks ही फँसा दें 💀死锁 — 当锁反过来咬人 💀

A deadlock happens when two or more threads each wait for a lock that another one holds. Nothing crashes and nothing prints — the program just freezes.

Deadlock तब होता है जब दो या ज़्यादा threads हर एक ऐसे lock का इंतज़ार करते हैं जो किसी दूसरे के पास है। कुछ crash नहीं होता, कुछ print नहीं होता — program बस जम जाता है।

当两个或更多线程各自等待另一个线程持有的锁时，就发生了 死锁。没有崩溃，也没有输出 — 程序就这么冻住了。

import threading, time

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

def thread_a():
    with lock1:
        print("A got lock1")
        time.sleep(0.1)           # give B time to grab lock2
        with lock2:               # will wait FOREVER
            print("A got lock2 (never prints)")

def thread_b():
    with lock2:
        print("B got lock2")
        time.sleep(0.1)
        with lock1:               # will wait FOREVER
            print("B got lock1 (never prints)")

threading.Thread(target=thread_a).start()
threading.Thread(target=thread_b).start()
# Program hangs - Ctrl-C to exit

A grabs lock1 and B grabs lock2. The short sleep makes sure both happen before either asks for its second lock. Then A waits for lock2 (held by B) and B waits for lock1 (held by A). Our run printed two lines and then sat still until we killed it.

A lock1 लेता है और B lock2। छोटा sleep पक्का करता है कि दोनों अपना दूसरा lock माँगने से पहले हो जाएँ। फिर A lock2 (B के पास) का इंतज़ार करता है और B lock1 (A के पास) का। हमारे run ने दो lines print कीं और फिर तब तक रुका रहा जब तक हमने उसे बंद नहीं किया।

A 拿到 lock1，B 拿到 lock2。短暂的 sleep 确保两者都在请求第二把锁之前完成。接着 A 等待 lock2（被 B 持有），B 等待 lock1（被 A 持有）。我们的运行打印了两行，然后一直静止，直到我们把它杀掉。

💀 Simulator: Deadlock Lab💀 Simulator: Deadlock Lab💀 模拟器：死锁实验室

Three versions of the two-lock program, each run for real (events in seconds). Watch the lock graph: a green line means "holds", a red dashed arrow means "waits for". A red cycle is a deadlock.

दो-lock program के तीन versions, हर एक असल में चलाया गया (events seconds में)। Lock graph देखिए: हरी line मतलब "रखे है", लाल dashed तीर मतलब "इंतज़ार कर रहा है"। लाल चक्र = deadlock।

双锁程序的三个版本，每个都真实运行过（事件以秒为单位）。观察锁关系图：绿线表示"持有"，红色虚线箭头表示"等待"。红色的环就是死锁。

RLock — The Reentrant Lock 🔁RLock — Reentrant Lock 🔁RLock — 可重入锁 🔁

Sometimes one thread needs to acquire the same lock more than once — usually because one locked function calls another locked function. With a plain Lock the thread blocks against itself. RLock (reentrant lock) fixes this: it remembers which thread owns it and how many times that thread has acquired it.

कभी-कभी एक thread को उसी lock को एक से ज़्यादा बार acquire करना पड़ता है — आम तौर पर क्योंकि एक locked function दूसरे locked function को बुलाता है। साधारण Lock के साथ thread ख़ुद से ही अटक जाता है। RLock (reentrant lock) इसे ठीक करता है: यह याद रखता है कि कौन-सा thread इसका मालिक है और उसने इसे कितनी बार acquire किया है।

有时一个线程需要多次获取 同一把 锁 — 通常是因为一个加锁的函数调用了另一个加锁的函数。用普通的 Lock，线程会被自己阻塞。RLock（可重入锁）解决了这个问题：它记录 哪个线程拥有它，以及该线程 获取了多少次。

The problem a plain Lock createsसाधारण Lock की पैदा की हुई समस्या普通 Lock 带来的问题

import threading

lock = threading.Lock()

def deposit(amount):
    with lock:                        # acquire #1
        print(f"deposit {amount}")
        audit(f"deposit of {amount}") # calls audit - which also locks!

def audit(msg):
    with lock:                        # acquire #2 - SELF-DEADLOCK
        print(f"[audit] {msg}")

t = threading.Thread(target=deposit, args=(100,), daemon=True)
t.start()
t.join(timeout=2)
print(f"alive after 2s? {t.is_alive()}")    # True - deadlocked

The fix — use RLockFix — RLock लीजिए修复 — 使用 RLock

import threading

rlock = threading.RLock()             # reentrant version

def deposit(amount):
    with rlock:                       # count = 1
        print(f"deposit {amount}")
        audit(f"deposit of {amount}")

def audit(msg):
    with rlock:                       # count = 2 - same thread, OK
        print(f"[audit] {msg}")

t = threading.Thread(target=deposit, args=(100,))
t.start()
t.join()
print("finished cleanly")

How the counter works — nested acquiresCounter कैसे चलता है — nested acquires计数器如何工作 — 嵌套获取

import threading

lock = threading.RLock()

def first(n):
    print("In first", n)
    lock.acquire()                # count: 1 -> 2  (same thread, allowed)
    a = 12 + n
    lock.release()                # count: 2 -> 1
    print(a)

def second(n):
    lock.acquire()                # count: 1 -> 2  (same thread, allowed)
    b = 12 + n
    lock.release()                # count: 2 -> 1
    print(b)

def all():
    print("start")
    lock.acquire()                # count: 0 -> 1  (thread owns it now)
    first(2)                      # re-acquires + releases inside
    second(3)                     # re-acquires + releases inside
    lock.release()                # count: 1 -> 0  (truly freed)

th1 = threading.Thread(target=all)
th1.start()

Problem #2 — cross-thread release (where RLock refuses)समस्या #2 — दूसरे thread से release (जहाँ RLock मना करता है)问题 #2 — 跨线程释放（RLock 拒绝的情况）

Here is a case that looks like RLock should save us — but it cannot, because RLock enforces ownership. One thread acquires and never releases; a different thread tries to release for it.

यह ऐसा case है जिसमें लगता है RLock बचा लेगा — पर नहीं बचा सकता, क्योंकि RLock मालिकाना हक़ लागू करता है। एक thread acquire करता है और कभी release नहीं करता; दूसरा thread उसकी जगह release करने की कोशिश करता है।

下面这个案例看起来 RLock 应该能救场 — 但它不能，因为 RLock 强制执行 所有权。一个线程获取后从不释放；另一个线程试图替它释放。

import threading
import time
import datetime

lock = threading.RLock()
t1 = datetime.datetime.now()

def second(n):
    lock.acquire()                # acquires but NEVER releases!
    print(n)

def third():
    time.sleep(5)
    lock.release()                # releases a lock this thread never acquired!
    print("Thread3")

th1 = threading.Thread(target=second, args=("Thread1",))
th1.start()
th2 = threading.Thread(target=second, args=("Thread2",))
th2.start()
th3 = threading.Thread(target=third)
th3.start()

th1.join()
th2.join()
th3.join()
t2 = datetime.datetime.now()
print("Total time", t2 - t1)

The fix — each function manages its own lockFix — हर function अपना lock ख़ुद संभाले修复 — 每个函数自己管理锁

import threading, time, datetime

lock = threading.RLock()
t1 = datetime.datetime.now()

def second(n):
    with lock:                    # acquire + guaranteed release
        print(n)
        time.sleep(1)             # pretend we're doing critical work

def third():
    time.sleep(2)
    with lock:                    # properly acquire before touching shared state
        print("Thread3")

threads = [
    threading.Thread(target=second, args=("Thread1",)),
    threading.Thread(target=second, args=("Thread2",)),
    threading.Thread(target=third),
]
for t in threads: t.start()
for t in threads: t.join()
print("Total time", datetime.datetime.now() - t1)

🔁 Simulator: Lock vs RLock Playground🔁 Simulator: Lock बनाम RLock Playground🔁 模拟器：Lock vs RLock 游乐场

Two threads, A and B, share one lock. Click buttons to make a thread call acquire(blocking=False) (so nothing ever hangs) or release(). Switch between Lock and RLock and compare. The rules match 300 random sequences we ran with real threads.

दो threads, A और B, एक lock बाँटते हैं। Buttons click करके किसी thread से acquire(blocking=False) (ताकि कुछ अटके नहीं) या release() बुलवाइए। Lock और RLock के बीच बदलकर तुलना कीजिए। ये नियम असली threads के साथ चलाए गए 300 random sequences से मिलते हैं।

两个线程 A 和 B 共享一把锁。点击按钮让某个线程调用 acquire(blocking=False)（这样不会卡住）或 release()。在 Lock 和 RLock 之间切换并比较。这些规则与我们用真实线程运行的 300 个随机序列完全一致。

Lock vs RLock — Side by Side ⚖️Lock बनाम RLock — आमने-सामने ⚖️Lock 与 RLock — 并排对比 ⚖️

import timeit

for kind in ("Lock", "RLock"):
    t = timeit.timeit("with lock: pass",
                      setup=f"import threading; lock = threading.{kind}()",
                      number=1_000_000)
    print(f"{kind:5s}: 1,000,000 acquire+release in {t:.2f} s")

Real-World Example — A Thread-Safe Bank Account 🏦असली उदाहरण — Thread-Safe Bank Account 🏦实战示例 — 线程安全的银行账户 🏦

A BankAccount class that many threads can use at once. transfer() calls withdraw() and deposit(), and all three take the account's lock — nested locking, so RLock is the natural choice. Three customers each do five rounds of deposit, withdraw and transfer.

एक BankAccount class जिसे कई threads एक साथ इस्तेमाल कर सकते हैं। transfer() withdraw() और deposit() बुलाता है, और तीनों account का lock लेते हैं — nested locking, इसलिए RLock स्वाभाविक चुनाव है। तीन customers हर एक deposit, withdraw और transfer के पाँच rounds करते हैं।

一个可以被多个线程同时使用的 BankAccount 类。transfer() 会调用 withdraw() 和 deposit()，三者都会获取账户的锁 — 这是嵌套加锁，所以 RLock 是自然的选择。三个客户各自进行五轮存款、取款和转账。

import threading, time

class BankAccount:
    def __init__(self, name, balance=0):
        self.name = name
        self.balance = balance
        self.lock = threading.RLock()      # reentrant - allows nesting

    def deposit(self, amount):
        with self.lock:
            new_bal = self.balance + amount
            time.sleep(0.001)              # simulate DB latency
            self.balance = new_bal

    def withdraw(self, amount):
        with self.lock:
            if amount > self.balance:
                raise ValueError(f"{self.name}: insufficient funds")
            new_bal = self.balance - amount
            time.sleep(0.001)
            self.balance = new_bal

    def transfer(self, to_account, amount):
        with self.lock:                    # outer lock on source
            with to_account.lock:          # lock on destination
                self.withdraw(amount)      # re-acquires self.lock - OK with RLock
                to_account.deposit(amount) # re-acquires to_account.lock - OK

alice = BankAccount("alice", 1000)
bob = BankAccount("bob", 1000)

def busy_customer():
    for _ in range(5):
        alice.deposit(10)          # money comes IN from outside
        bob.withdraw(5)            # money goes OUT to the customer
        alice.transfer(bob, 20)    # money moves INSIDE the bank

threads = [threading.Thread(target=busy_customer, name=f"cust-{i}") for i in range(3)]
for t in threads: t.start()
for t in threads: t.join()

expected = 2000 + 3 * 5 * 10 - 3 * 5 * 5
print(f"final:  alice={alice.balance}  bob={bob.balance}")
print(f"total:  {alice.balance + bob.balance}   (expected {expected}: 2000 + 150 deposited - 75 withdrawn)")

Now the same program with every lock removed (with self.lock: replaced by if True:). Same customers, same amounts:

अब वही program हर lock हटाकर (with self.lock: की जगह if True:)। वही customers, वही रक़में:

现在是去掉所有锁的同一个程序（把 with self.lock: 换成 if True:）。同样的客户，同样的金额：

Common Pitfalls and the Bug Doctor 🩺आम ग़लतियाँ और Bug Doctor 🩺常见陷阱与 Bug 医生 🩺

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

Six real mistakes from this tutorial. Buggy code on the left, fixed code on the right, changed lines marked. Every output is from a real run (programs that would hang were given daemon threads or timeouts so they could report).

इस tutorial की छह असली ग़लतियाँ। बाईं ओर buggy code, दाईं ओर ठीक किया हुआ, बदली lines चिह्नित। हर output असली run से है (जो programs अटक जाते उन्हें daemon threads या timeouts दिए गए ताकि वे नतीजा बता सकें)।

本教程中的六个真实错误。左边是有 bug 的代码，右边是修正后的代码，改动的行已标出。每个输出都来自真实运行（会挂起的程序被改用守护线程或超时，以便能报告结果）。

Golden Rules and Quiz 🏆सुनहरे नियम और Quiz 🏆黄金法则与小测验 🏆

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