Python RLock可重入锁详解 - 递归加锁与嵌套调用

# 线程同步RLock相关语法示例
import threading

# 创建可重入锁
rlock = threading.RLock()

# 基本使用
rlock.acquire()      # 第一次获取锁
rlock.acquire()      # 第二次获取锁（同一线程可以重入）
try:
    # 临界区代码
    pass
finally:
    rlock.release()  # 第一次释放
    rlock.release()  # 第二次释放（必须与acquire次数匹配）

# 使用with语句（推荐）
with rlock:
    # 外层临界区
    with rlock:      # 可以嵌套使用
        # 内层临界区
        pass

# RLock vs Lock
# Lock: 同一线程不能多次获取，会导致死锁
# RLock: 同一线程可以多次获取，通过计数器管理

# 基本用法示例
import threading

class SharedResource:
    """需要嵌套加锁的共享资源"""
    def __init__(self):
        self.data = 0
        self.rlock = threading.RLock()
    
    def update(self, value):
        """更新数据（需要加锁）"""
        with self.rlock:
            print(f"获取锁，准备更新")
            self.data += value
            self._validate()  # 调用内部方法也需要锁
    
    def _validate(self):
        """验证数据（内部方法，也需要锁）"""
        # 使用RLock，同一线程可以再次获取锁
        with self.rlock:
            if self.data < 0:
                self.data = 0
            print(f"验证完成，当前值: {self.data}")

# 创建资源实例
resource = SharedResource()

# 多线程访问
def worker(value):
    resource.update(value)

threads = []
for i in range(5):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"最终数据: {resource.data}")

# 详细代码示例：递归函数中的RLock使用
import threading
import time

class RecursiveProcessor:
    """递归处理器 - 演示RLock在递归场景的应用"""
    def __init__(self):
        self.results = []
        self.rlock = threading.RLock()
    
    def process(self, data, depth=0):
        """递归处理数据"""
        with self.rlock:  # 每次递归都可以获取锁
            indent = "  " * depth
            print(f"{indent}处理: {data}")
            time.sleep(0.1)  # 模拟处理时间
            
            self.results.append(data)
            
            # 递归调用
            if isinstance(data, list):
                for item in data:
                    self.process(item, depth + 1)
            elif isinstance(data, dict):
                for key, value in data.items():
                    print(f"{indent}  键: {key}")
                    self.process(value, depth + 1)

# 创建处理器
processor = RecursiveProcessor()

# 复杂嵌套数据结构
complex_data = {
    "users": [
        {"name": "Alice", "age": 30},
        {"name": "Bob", "age": 25}
    ],
    "settings": {
        "theme": "dark",
        "notifications": True
    }
}

# 多线程处理
def process_worker(data):
    processor.process(data)

threads = []
for i in range(3):
    t = threading.Thread(target=process_worker, args=(complex_data,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"处理结果数量: {len(processor.results)}")