Python threading.RLock 线程递归锁

说明

《Python 教程》持续更新中，提供建议、纠错、催更等加作者微信: gairuo123（备注：pandas教程）和关注公众号「盖若」ID: gairuo。跟作者学习，请进入 Python学习课程。欢迎关注作者出版的书籍：《深入浅出Pandas》和《Python之光》。

Python 中的递归锁（RLock）是一种特殊的锁，它允许一个线程多次对其进行 acquire 操作，而不会导致死锁。递归锁主要用于解决同一线程需要多次获取锁的情况。

递归锁的原理

递归锁允许同一个线程在没有释放锁的情况下，多次获取该锁。这在某些函数可能会在已经持有锁的情况下再次调用自身或者其他需要获取相同锁的函数时非常有用。而普通的锁（Lock）在同一线程再次获取时会导致死锁。

递归锁在内部维护了一个计数器和一个锁定状态。当一个线程首次请求锁时，计数器加一并成功获取锁；每次成功获取锁时，计数器加一。当线程释放锁时，计数器减一；只有当计数器为零时，锁才被完全释放。

递归锁对象

构造很简单：

import threading

rlock = threading.RLock()

创建一个新的递归锁对象。支持使用 with 语句。与普通锁的 acquire() 和 release() 方法类似，只是可以在同一个线程中多次调用 acquire() 而不会阻塞。

当一个线程可能需要在已经持有锁的情况下再次获取锁来完成一些嵌套的操作时，就适合使用递归锁。

示例

简单使用示例代码：

import threading

lock = threading.RLock()

def recursive_function(level):
    if level > 0:
        lock.acquire()
        print(f"进入递归，级别: {level}")
        recursive_function(level - 1)
        lock.release()

thread = threading.Thread(target=recursive_function, args=(3,))
thread.start()
thread.join()

另外：

import threading

counter = 0
rlock = threading.RLock()

def increment():
    global counter
    with rlock:
        counter += 1
        print(f"Counter value: {counter}")
        if counter < 5:
            increment()  # 调用自身

threads = [threading.Thread(target=increment) for _ in range(3)]

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

print("Final counter value:", counter)

案例

假设有一个资源管理类，其中的某些方法可能会相互调用，并且都需要获取锁来保护资源的一致性。

import threading

class ResourceManager:
    def __init__(self):
        self.lock = threading.RLock()
        self.resource = 0

    def operation1(self):
        self.lock.acquire()
        self.resource += 1
        print(f"操作 1，资源值: {self.resource}")
        self.operation2()
        self.lock.release()

    def operation2(self):
        self.lock.acquire()
        self.resource += 2
        print(f"操作 2，资源值: {self.resource}")
        self.lock.release()

manager = ResourceManager()

threads = [
    threading.Thread(target=manager.operation1),
    threading.Thread(target=manager.operation1)
]

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

print("最终资源值:", manager.resource)

在上述案例中，operation1 方法调用了 operation2 方法，并且都需要获取锁来操作资源，使用递归锁可以避免死锁并保证资源操作的正确性。

案例二

以下是一个综合案例，展示如何使用递归锁在递归调用中保护共享资源：

import threading
import time

class SharedResource:
    def __init__(self):
        self.counter = 0
        self.rlock = threading.RLock()

    def increment(self):
        with self.rlock:
            self.counter += 1
            print(f"Counter value: {self.counter}")
            if self.counter < 5:
                time.sleep(1)  # 模拟处理时间
                self.increment()  # 递归调用

shared_resource = SharedResource()
threads = []

for _ in range(3):
    t = threading.Thread(target=shared_resource.increment)
    threads.append(t)

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

print("Final counter value:", shared_resource.counter)

代码说明：

递归调用：在 increment 方法中，使用递归方式调用自身来模拟复杂的处理逻辑。
递归锁的作用：递归锁确保在递归调用过程中，多个线程可以多次获取锁，而不会造成死锁或竞争条件。
线程同步：保证了 counter 资源的线程安全性，即使在递归调用的过程中也能正确地维护和更新共享资源。

参考

https://docs.python.org/zh-cn/3/library/threading.html#threading.RLock

< Lock 线程锁 Python 模块 threading 基于线程的并行 Condition 线程条件对象 >

更新时间：2024-06-30 17:19:43 标签：python threading 线程递归锁