python线程里嵌套锁问题lock和Rlock剖析

基础：

锁提供如下方法： 
1.Lock.acquire(blocking=True, timeout=-1)：请求对 Lock 或 RLock 加锁，其中 timeout 参数指定加锁多少秒。

      Lock 和 RLock 的区别如下：

• threading.Lock：它是一个基本的锁对象，每次只能锁定一次，其余的锁请求，需等待锁释放后才能获取。
• threading.RLock：它代表可重入锁（Reentrant Lock）。对于可重入锁，在同一个线程中可以对它进行多次锁定，也可以多次释放。如果使用 RLock，那么 acquire() 和 release() 方法必须成对出现。如果调用了 n 次 acquire() 加锁，则必须调用 n 次 release() 才能释放锁。

2.Lock.release() 
3.threading.Lock() 加载线程的锁对象，是一个基本的锁对象，一次只能一个锁定，其余锁请求，需等待锁释放后才能获取4.threading.RLock() 多重锁，在同一线程中可用被多次acquire。如果使用RLock，那么acquire和release必须成对出现， 
调用了n次acquire锁请求，则必须调用n次的release才能在线程中释放锁对象

直奔主题测试代码案例：

lock和Rlock内部源码实现方式不一样，具体可以查看源码。再说测试部分（环境windows和vscode）：

import threading,time

# run1第二道锁
def run1():
    print("grab the first part data")
    lock.acquire()
    global num
    num +=1
    lock.release()
    return num

# run2第三道锁
def run2():
    print("grab the second part data")
    lock.acquire()
    global  num2
    num2+=1
    lock.release()
    return num2

# run3相当于第一道锁
def run3():
    # 获取一把锁
    lock.acquire()
    res = run1()
    print('--------between run1 and run2-----')
    time.sleep(0.3)
    res2 = run2()
    # 释放一把锁
    lock.release()
    print(res,res2)
    print(threading.active_count())
# 生成两个变量
num,num2 = 0,0

# 生成递归锁实例
lock = threading.Lock()
lock2= threading.Lock() 
lock3 = threading.Lock()
# 循环开启10个线程
for i in range(10):
    print(threading.active_count())
    t = threading.Thread(target=run3)
    t.start()
t.join()
# 如过大于1个线程就成立,注意IDE线程可能不一样
while threading.active_count() != 7:
    print('----all threads over---')
    print(threading.active_count())
    # 打印当前还有多少个线程
    # print(threading.active_count())
else:
    print('----all threads done---')
    print(num,num2)
    print(threading.active_count())

 从上面的测试用例可以得到，程序卡在run1（）函数lock.acquire()里面了。所以可以得到一个结论：锁是一个全局对象，所里面不要嵌套锁。

解决办法：low一点的，用多少锁定义几个锁，区分开：

lock = threading.Lock()

lock2= threading.Lock()

lock3 = threading.Lock()

或者直接使用python为我们准备的多个嵌套threading.RLock()。这里就不贴代码，只要将上面lock = threading.RLock()修改一下就可以了。

这里还有一个注意点：

# 如过大于1个线程就成立,注意IDE线程可能不一样
while threading.active_count() != 7: #注意点
    print('----all threads over---')
    print(threading.active_count())
    # 打印当前还有多少个线程
    # print(threading.active_count())
else:
    print('----all threads done---')
    print(num,num2)
    print(threading.active_count())

这个线程当前数，在不同的IDE编译环境下不一样。有的IDE只是1，相当于只有一个main（）主函数（提示：主函数其实也是一个线程）

————————————————————————————————————————————————————————

以下是在其他地方看到拓展案例，也会造成死锁：

import threading
import time

class A:
    def __init__(self):
        self.lock = threading.RLock()
    def foo(self, b):
        try:
            self.lock.acquire()
            print("当前线程名: " + threading.current_thread().name\
                + " 进入了A实例的foo()方法" )     # ①
            time.sleep(0.2)
            print("当前线程名: " + threading.current_thread().name\
                + " 企图调用B实例的last()方法")   # ③
            b.last()
        finally:
            self.lock.release()
    def last(self):
        try:
            self.lock.acquire()
            print("进入了A类的last()方法内部")
        finally:
            self.lock.release()
class B:
    def __init__(self):
        self.lock = threading.RLock()
    def bar(self, a):
        try:
            self.lock.acquire()
            print("当前线程名: " + threading.current_thread().name\
                + " 进入了B实例的bar()方法" )   # ②
            time.sleep(0.2)
            print("当前线程名: " + threading.current_thread().name\
                + " 企图调用A实例的last()方法")  # ④
            a.last()
        finally:
            self.lock.release()
    def last(self):
        try:
            self.lock.acquire()
            print("进入了B类的last()方法内部")
        finally:
            self.lock.release()
a = A()
b = B()
def init():
    threading.current_thread().name = "主线程"
    # 调用a对象的foo()方法
    a.foo(b)
    print("进入了主线程之后")
def action():
    threading.current_thread().name = "副线程"
    # 调用b对象的bar()方法
    b.bar(a)
    print("进入了副线程之后")
# 以action为target启动新线程
threading.Thread(target=action).start()
# 调用init()函数
init()

至此，就出现了主线程保持着 A 对象的锁，等待对 B 对象加锁，而副线程保持着 B对象的锁，等待对 A 对象加锁，两个线程互相等待对方先释放锁，所以就出现了死锁。

死锁是不应该在程序中出现的，在编写程序时应该尽量避免出现死锁。下面有几种常见的方式用来解决死锁问题：

1. 避免多次锁定。尽量避免同一个线程对多个 Lock 进行锁定。例如上面的死锁程序，主线程要对 A、B 两个对象的 Lock 进行锁定，副线程也要对 A、B 两个对象的 Lock 进行锁定，这就埋下了导致死锁的隐患。
2. 具有相同的加锁顺序。如果多个线程需要对多个 Lock 进行锁定，则应该保证它们以相同的顺序请求加锁。比如上面的死锁程序，主线程先对 A 对象的 Lock 加锁，再对 B 对象的 Lock 加锁；而副线程则先对 B 对象的 Lock 加锁，再对 A 对象的 Lock 加锁。这种加锁顺序很容易形成嵌套锁定，进而导致死锁。如果让主线程、副线程按照相同的顺序加锁，就可以避免这个问题。
3. 使用定时锁。程序在调用 acquire() 方法加锁时可指定 timeout 参数，该参数指定超过 timeout 秒后会自动释放对 Lock 的锁定，这样就可以解开死锁了。
4. 死锁检测。死锁检测是一种依靠算法机制来实现的死锁预防机制，它主要是针对那些不可能实现按序加锁，也不能使用定时锁的场景的。