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. 死锁检测。死锁检测是一种依靠算法机制来实现的死锁预防机制,它主要是针对那些不可能实现按序加锁,也不能使用定时锁的场景的。
Python线程编程中,Lock)和可重入(RLock)都是常用的同步机制,用于保护共享资源,防止多个线程同时访问导致数据错误。 Lock是一种最基本的,它将资源住,直到被释放。当一个线程获得时,其他线程必须等待该线程释放后才能获得。这种是不可重入的,即同一个线程不能重复获得同一把。 RLock是可重入,它允许一个线程多次获得同一把。当一个线程获得时,它可以再次获得这个而不会被阻塞。只有该线程释放的次数与获得的次数相等时,其他线程才能获得该。可重入在需要多次获得同一把的场景中很有用。 下面是使用Lock和RLock的示例代码: ```python import threading # 创建一个Lock对象 lock = threading.Lock() # 创建一个RLock对象 rlock = threading.RLock() # 使用Lock保护共享资源 class Counter(object): def __init__(self): self.value = 0 def increment(self): lock.acquire() try: self.value += 1 finally: lock.release() # 使用RLock保护共享资源 class ReentrantCounter(object): def __init__(self): self.value = 0 def increment(self): rlock.acquire() try: self.value += 1 # 再次获得 rlock.acquire() try: self.value += 1 finally: rlock.release() finally: rlock.release() ``` 在上面的代码中,Counter类使用Lock保护value属性,而ReentrantCounter类使用RLock保护value属性。在increment方法中,Counter使用lock.acquire()和lock.release()获取和释放,在同一时间只允许一个线程访问value属性。而ReentrantCounter使用rlock.acquire()和rlock.release()获取和释放,并且在方法内部重复获得,这是RLock的特性。 需要注意的是,使用时要避免死的情况发生,即多个线程相互等待对方释放的情况。因此,在编写代码时要考虑好的获取和释放顺序,以避免死的发生。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

路奇怪

有钱出钱,没钱多出编程主意啊

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值