可重入锁如何保证互斥性？重复获取为何不破坏互斥？

先给你明确结论：可重入锁完全不会破坏互斥性，它的“重入”权限仅针对持有锁的同一个线程，其他线程仍然无法抢占该锁，完全保留了互斥性的核心——同一时间只有一个线程持有锁。

可重入锁的实现逻辑 #

它内部维护两个核心状态：

• 当前持有锁的线程ID
• 该线程获取锁的次数（重入计数）

当线程尝试获取锁时：

1. 若锁未被任何线程持有，直接获取锁，将重入计数设为1
2. 若锁已被当前线程持有，直接允许重入，重入计数加1
3. 若锁被其他线程持有，当前线程进入等待队列，直到锁被彻底释放

实际场景看互斥性如何保障 #

比如递归函数中使用可重入锁的例子：

import threading

# 初始化可重入锁
reentrant_lock = threading.RLock()

def recursive_operation(deep):
    if deep == 0:
        return
    # 第一次获取锁
    reentrant_lock.acquire()
    print(f"线程{threading.get_ident()}进入第{deep}层递归")
    # 递归调用时再次获取锁（重入）
    recursive_operation(deep - 1)
    # 每一次获取都对应一次释放
    reentrant_lock.release()

# 启动第一个线程执行递归
thread1 = threading.Thread(target=recursive_operation, args=(3,))
thread1.start()

# 启动第二个线程尝试抢占锁
thread2 = threading.Thread(target=recursive_operation, args=(2,))
thread2.start()

thread1.join()
thread2.join()

运行这段代码你会发现，thread2会全程等待，直到thread1将所有重入的锁都释放（重入计数减至0）后，才会开始执行——这就明确证明了可重入锁依然严格保证了不同线程之间的互斥性。

总结 #

可重入锁的设计初衷是解决同一线程重复获取锁导致的死锁问题（比如递归场景下用普通互斥锁会直接死锁），但它从未削弱互斥性的核心规则：锁始终只能被一个线程持有，其他线程必须等待该线程完全释放锁后才能获取。

内容的提问来源于stack exchange，提问作者Chintamani Chourase