Python多线程 threading模块[6] 可重入锁RLock

       考虑这种情况：

       如果一个线程遇到锁嵌套的情况该怎么办，这个嵌套是指当我一个线程在获取临界资源时，又需要再次获取。根据这种情况，代码如下：

# !/usr/bin/python3
# coding: utf-8
import threading

lock = threading.Lock()


class MyThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        global lock
        if lock.acquire():
            print("%s get L" % self.name)

            if lock.acquire():
                print("%s get LAgain" % self.name)
                lock.release()
                print("%s release LAgain" % self.name)

            print("%s release L" % self.name)
            lock.release()


if __name__ == "__main__":
    for i in range(0, 3):
        my_thread = MyThread()
        my_thread.start()

       这种情况的代码运行情况如下：

Thread-1 get L

 

       之后就直接挂起了，这种情况形成了最简单的死锁。

       那有没有一种情况可以在某一个线程使用互斥锁访问某一个竞争资源时，可以再次获取呢？在Python中为了支持在同一线程中多次请求同一资源，python提供了“可重入锁”：threading.RLock。这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：

只需将原代码

lock = threading.Lock()

改成

lock = threading.RLock()

即可。

 

执行结果如下

Thread-1 get L
Thread-1 get LAgain
Thread-1 release LAgain
Thread-1 release L

Thread-2 get L
Thread-2 get LAgain
Thread-2 release LAgain
Thread-2 release L

Thread-3 get L
Thread-3 get LAgain
Thread-3 release LAgain
Thread-3 release L

 

相关阅读

《Python多线程 threading模块[1] 概述》

《Python多线程 threading模块[2] 两种方式启动线程》

《Python多线程 threading模块[3] Thread类的重要函数》

《Python多线程 threading模块[4] Lock互斥锁》

《Python多线程 threading模块[5] 死锁的形成》

《Python多线程 threading模块[6] 可重入锁RLock》

《Python多线程 threading模块[7] Event线程通信》

《Python多线程 threading模块[8] Condition实现复杂同步》