Python的线程15 可重入锁RLock

Posted 2022-02-21 雷学委

正式的Python专栏第52篇，同学站住，别错过这个从0开始的文章！

前面学委介绍线程安全的时候，提到过threading.Lock这个类。

这个所以我们acquire之后，就不能继续acquire了，必须执行一次release，其他线程才可以继续acquire。

这样一个时间只有一个线程做事情，这次我们看看RLock（ReentrantLock，可重入锁）。

RLock 是什么？

简单理解，它跟Lock类似，都是用来协调对受限资源的访问，加上锁来保护受限资源的访问。

但是，它们还是有明显的区别的。 第一个是，RLock可以被acquire多次。

我们看看下面的代码：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2021/11/24 12:02 上午
# @Author : LeiXueWei
# @CSDN/Juejin/Wechat: 雷学委
# @XueWeiTag: CodingDemo
# @File : __init__.py.py
# @Project : hello
import random
import threading
import datetime
import time

xuewei_account = 100
lock = threading.RLock()


# amount为负数即是转出金额
def transfer(money):
    transfer_only(money)
    lock.release()
    print("release")


# amount为负数即是转出金额
def transfer_only(money):
    lock.acquire()
    print("transfer now")
    global xuewei_account
    for x in range(100000):
        xuewei_account += money
    print("transfer done")


transfer_only(100)
transfer_only(-100)
print("-" * 16)
print("学委账户余额：", xuewei_account)

运行效果如下：

transfer_only 函数被调用了两次，但我们还没有release过。

整个过程没有阻塞。

我们把使用Lock的代码展示一下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2021/11/24 12:02 上午
# @Author : LeiXueWei
# @CSDN/Juejin/Wechat: 雷学委
# @XueWeiTag: CodingDemo
# @File : __init__.py.py
# @Project : hello
import random
import threading
import datetime
import time

xuewei_account = 100
lock = threading.Lock()


# amount为负数即是转出金额
def transfer(money):
    transfer_only(money)
    lock.release()
    print("release")


# amount为负数即是转出金额
def transfer_only(money):
    lock.acquire()
    print("transfer now")
    global xuewei_account
    for x in range(100000):
        xuewei_account += money
    print("transfer done")


transfer_only(100)
transfer_only(-100)
print("-" * 16)
print("学委账户余额：", xuewei_account)

运行效果如下：

两断代码的区别，仅仅为创造lock对象的时候，前者是基于RLock类型，后者是基于Lock（普通的锁）。

但我们看到Lock，不允许持有锁的线程（同一个或者其他线程）再次acqure，transfer_only仅仅执行完一次。

多个线程能不能都来acquire RLock

试试多个线程acquire，代码如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2021/11/24 12:02 上午
# @Author : LeiXueWei
# @CSDN/Juejin/Wechat: 雷学委
# @XueWeiTag: CodingDemo
# @File : __init__.py.py
# @Project : hello
import random
import threading
import datetime
import time

xuewei_account = 100
lock = threading.RLock()


# amount为负数即是转出金额
def transfer(money):
    transfer_only(money)
    lock.release()
    print("release")


# amount为负数即是转出金额
def transfer_only(money):
    lock.acquire()
    print("transfer now")
    global xuewei_account
    for x in range(100000):
        xuewei_account += money
    print("transfer done")


threading.Thread(name="thread小白", target=lambda: transfer_only(100)).start()
threading.Thread(name="thread小花", target=lambda: transfer_only(-100)).start()
print("-" * 16)
print("学委账户余额：", xuewei_account)

运行效果如下：

很明显，第二个线程被锁定了。

这个符合RLock的设定，运行获取锁的线程多次acqure，但是必须release之后才能重新分配给其他线程。

两断代码区别仅仅为：

第一段，我们是在主线程，也就是同一个线程多次acquire RLock对象。

transfer_only(100)
transfer_only(-100)

第二段，我们是在两个不同线程间多次acquire RLock对象。（虽然没有打印出来，但是这里线程名称也特意设置不一样了，读者可以修改打印查看核对）

threading.Thread(name="thread小白", target=lambda: transfer_only(100)).start()
threading.Thread(name="thread小花", target=lambda: transfer_only(-100)).start()

总结

今天这篇我们先简单了解了RLock，它的设计让我们在一个线程内可以多次使用锁。

它优先分配锁给持有锁的线程，减少线程切换的消耗，更重要的是，可重入锁设计更利于防止死锁。（这里简单举例，想象一下，一个线程调用多个方法都在acquire同个锁，这时候使用普通Lock就会进入死锁状态，后面学委再写一篇吧）

但是release必须要获取锁的线程进行，而且acquire几次就必须release几次，这个下篇再展示。

喜欢Python的朋友，请关注学委的 Python基础专栏 or Python入门到精通大专栏

持续学习持续开发，我是雷学委！
编程很有趣，关键是把技术搞透彻讲明白。
欢迎关注微信，点赞支持收藏!