Python并发编程中线程锁的使用与可重入锁详解

沈亦白

发布时间：2026-10-15 | 3人浏览过

原创

本文深入解析Python并发场景下的线程锁机制。通过电商库存扣减实例，阐述加锁防止数据竞争的必要性。详细对比threading.Lock的两种实现方式：手动acquire/release与with语句，并指出忘记释放锁的风险。进一步介绍可重入锁RLock解决递归死锁的方案，帮助开发者避免常见并发陷阱。

前言

具备操作系统基础知识的读者对锁的概念应当不陌生。线程锁的核心作用在于确保特定逻辑或资源在任意时刻仅能被单一线程访问。这一机制类似于一个被锁住的房间，唯有持有钥匙者方可进入；使用者进入后取走钥匙，离开时归还，后续者方可再次获取。在此隐喻中，房间代表资源或代码逻辑，而取用钥匙的行为对应线程对资源的访问。

加锁的原因

理解锁的原理后，一个关键问题浮现：为何必须使用锁？它适用于哪些具体场景？

锁的应用范围极广，以电商购物为例即可说明。商家库存有限，每售出一件库存即减少。假设某商品仅剩一件库存，此时两个用户同时发起购买请求。若不加锁保护，两个线程可能同时读取到库存为1且大于0，随后同时执行扣减逻辑。由于并发执行，最终库存可能变为-1，这显然不符合业务逻辑。

库存出现负数显然不合理，因此必须避免此类竞态条件。通过加锁机制，可强制规定同一时刻仅允许一个线程执行购买逻辑。当第一个线程将库存减至0并释放锁后，第二个线程无法再修改数据，从而确保数据的一致性与准确性。

代码实现

在Python中，如何实现上述锁机制？

实现方式十分直观。Python标准库threading已提供完善的线程工具，直接调用即可。通过实例化threading模块中的Lock对象，可轻松实现方法级别的加锁功能。

import threading
class PurchaseRequest:
    '''
    初始化库存与锁
    '''
    def __init__(self, initial_value = 0):
        self._value = initial_value
        self._lock = threading.Lock()

    def incr(self,delta=1):
        '''
        加库存
        '''
        self._lock.acquire()
        self._value += delta
        self._lock.release()

    def decr(self,delta=1):
        '''
        减库存
        '''
        self._lock.acquire()
        self._value -= delta
        self._lock.release()

从代码结构可见，进入临界区（资源竞争区）前，需先调用lock.acquire()获取锁。Lock对象确保同一时刻仅有一个线程能成功获取锁，获取成功后线程继续执行后续代码。任务完成后，需调用release方法释放锁，相当于将钥匙“放回门口”，供其他线程使用。

实践中，许多程序员容易忽略调用release方法，导致锁未释放从而引发难以排查的Bug。此类分布式或并发场景下的错误往往难以通过常规测试发现，因为测试环境通常难以模拟高并发；Code Review时也易被忽略，因此一旦上线，排查难度较大。

为解决此问题，Lock提供了更优的使用方式：结合with语句。此前在文件操作中，with语句已用于自动处理try...except...finally及资源回收。此处同理，使用with语句后，无需手动管理锁的申请与释放，只需关注业务逻辑。因此，前述代码可重构为如下形式：

import threading

class PurchaseRequest:
    '''
    初始化库存与锁
    '''
    def __init__(self, initial_value = 0):
        self._value = initial_value
        self._lock = threading.Lock()

    def incr(self,delta=1):
        '''
        加库存
        '''
  with self._lock:
         self._value += delta

    def decr(self,delta=1):
        '''
        减库存
        '''
        with self._lock:
         self._value -= delta

如此改写后，代码结构是否更加清晰简洁？

可重入锁

前文所述为最基础的锁机制，实际开发中更常用的是可重入锁。

何谓可重入锁？简言之，当一个线程已持有锁时，它允许再次进入被该锁保护的代码区域。既然线程仍持有锁未释放，为何需要再次进入？这通常发生在递归调用场景中。

对前文示例稍作修改，情况便截然不同。

import threading
class PurchaseRequest:
    '''
    初始化库存与锁
    '''
    def __init__(self, initial_value = 0):
        self._value = initial_value
        self._lock = threading.Lock()

    def incr(self,delta=1):
        '''
        加库存
        '''
  with self._lock:
         self._value += delta

    def decr(self,delta=1):
        '''
        减库存
        '''
        with self._lock:
         self.incr(-delta)

观察上述decr方法，其内部调用incr来实现原有逻辑。然而，decr本身也是加锁方法，按常规逻辑需等待前一个锁释放后才能进入。由于线程已持有锁，再次尝试获取同一把锁将导致死锁。

解决此问题的方法是将Lock替换为可重入锁，仅需修改一行代码。

import threading

class PurchaseRequest:
    '''
    初始化库存与锁
    我们使用RLock代替了Lock，也可重入锁代替了普通锁
    '''
    def __init__(self, initial_value = 0):
        self._value = initial_value
        self._lock = threading.RLock()

    def incr(self,delta=1):
        '''
        加库存
        '''
  with self._lock:
         self._value += delta

    def decr(self,delta=1):
        '''
        减库存
        '''
        with self._lock:
         self.incr(-delta)