在文章实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《Python多线程死锁与递归锁详解》，聊聊，希望可以帮助到正在努力赚钱的你。

死锁是多线程竞争资源时因循环等待导致程序卡住的现象，如线程A持lock1等lock2、B持lock2等lock1；避免方法是统一加锁顺序并使用RLock支持同线程重复加锁，防止自我阻塞。

在Python多线程编程中，死锁（Deadlock）是一个常见且棘手的问题。它通常发生在多个线程竞争多个锁资源时，彼此相互等待对方释放锁，导致所有线程都无法继续执行。

什么是死锁？

假设有两个线程 A 和 B，以及两把锁 lock1 和 lock2：

• 线程 A 持有 lock1，并试图获取 lock2
• 线程 B 持有 lock2，并试图获取 lock1

这时，A 等 B 释放 lock2，B 等 A 释放 lock1，形成循环等待，程序卡住——这就是典型的死锁。

示例：产生死锁的代码

import threading
import time
lock1 = threading.Lock()
lock2 = threading.Lock()
def thread_1():
with lock1:
print("线程1 获取了 lock1")
time.sleep(1)
print("线程1 尝试获取 lock2")
with lock2:
print("线程1 获取了 lock2")
def thread_2():
with lock2:
print("线程2 获取了 lock2")
time.sleep(1)
print("线程2 尝试获取 lock1")
with lock1:
print("线程2 获取了 lock1")
t1 = threading.Thread(target=thread_1)
t2 = threading.Thread(target=thread_2)
t1.start()
t2.start()
t1.join()
t2.join()

运行这段代码，大概率会卡住，出现死锁。

如何避免死锁？使用递归锁 RLock

虽然 RLock（可重入锁）不能直接解决多锁交叉导致的死锁，但它允许同一个线程多次获取同一把锁，防止因重复加锁导致的自我阻塞。

更重要的是，避免死锁的关键是：保持加锁顺序一致。

改进方案：统一加锁顺序 + 使用 RLock 防止重复加锁问题

import threading
import time
使用 RLock 替代 Lock，支持同一线程重复进入
lock1 = threading.RLock()
lock2 = threading.RLock()
def worker_1():
print("线程1 开始")
with lock1:
print("线程1 获取 lock1")
time.sleep(0.5)
with lock2:  # 统一先 lock1 再 lock2
print("线程1 获取 lock2")
def worker_2():
print("线程2 开始")
with lock1:  # 同样先获取 lock1
print("线程2 获取 lock1")
time.sleep(0.5)
with lock2:
print("线程2 获取 lock2")
t1 = threading.Thread(target=worker_1)
t2 = threading.Thread(target=worker_2)
t1.start()
t2.start()
t1.join()
t2.join()

这个版本中，两个线程都按照 lock1 → lock2 的顺序加锁，避免了循环等待，从而防止死锁。

递归锁 RLock 的典型用途

当一个函数在持有锁的情况下调用另一个也需要同一把锁的函数时，普通 Lock 会导致阻塞，而 RLock 允许这种情况。

import threading
rlock = threading.RLock()
def func1():
with rlock:
print("func1 已加锁")
func2()  # 调用另一个需要同样锁的函数
def func2():
with rlock:  # 同一线程可再次获取锁
print("func2 也获得了锁")
t = threading.Thread(target=func1)
t.start()
t.join()

如果这里用的是 Lock()，程序会在进入 func2 时被自己阻塞。

总结建议

• 死锁主因是锁的获取顺序不一致或循环等待
• 使用 threading.RLock 可解决同一线程重复加锁问题
• 避免死锁的根本方法是：始终以相同顺序获取多个锁
• 设计时尽量减少锁的数量和嵌套层级
• 可以使用超时机制（acquire(timeout=)）来检测潜在死锁

基本上就这些。掌握锁的使用顺序和选择合适的锁类型，能有效避免多线程中的死锁问题。

到这里，我们也就讲完了《Python多线程死锁与递归锁解析》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！