死锁现象，递归锁

所谓死锁：是指两个或两个以上的进程或线程在执行过程中，因为争夺资源而造成的一种互相等待的现象，若无外力作用，他们将无法推进下去，此时称系统处于死锁状态或系统产生了死锁，这些永远在相互等待的进程称为死锁进程。

from threading import Thread

from threading import Lock

import time

lock_A = Lock()

lock_B = Lock()

class MyThread(Thread):

def run(self):

self.f1()

self.f2()

def f1(self):

lock_A.acquire()

print(f'{self.name}拿到了锁A')

lock_B.acquire()

print(f'{self.name}拿到了锁B')

lock_B.release()

lock_A.release()

def f2(self):

lock_B.acquire()

print(f'{self.name}拿到了锁B')

time.sleep(1)

lock_A.acquire()

print(f'{self.name}拿到了锁A')

lock_A.release()

lock_B.release()

if __name__ == '__main__':

for i in range(1,4):

t = MyThread()

t.start()

# Thread-1拿到了锁A

# Thread-1拿到了锁B

# Thread-1拿到了锁B

# Thread-2拿到了锁A

# 锁死了....

遇到死锁现象可通过 递归锁解决。

在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：

from threading import Thread

from threading import RLock

import time

lock_A = RLock()

class MyThread(Thread):

def run(self):

self.f1()

self.f2()

def f1(self):

lock_A.acquire()

print(f'{self.name}拿到了锁A')

lock_A.acquire()

print(f'{self.name}拿到了锁B')

lock_A.release()

lock_A.release()

def f2(self):

lock_A.acquire()

print(f'{self.name}拿到了锁B')

time.sleep(1)

lock_A.acquire()

print(f'{self.name}拿到了锁A')

lock_A.release()

lock_A.release()

if __name__ == '__main__':

for i in range(1,4):

t = MyThread()

t.start()

# Thread-1拿到了锁A

# Thread-1拿到了锁B

# Thread-1拿到了锁B

# Thread-1拿到了锁A

# Thread-2拿到了锁A

# Thread-2拿到了锁B

# Thread-2拿到了锁B

# Thread-2拿到了锁A

# Thread-3拿到了锁A

# Thread-3拿到了锁B

# Thread-3拿到了锁B

# Thread-3拿到了锁A

'''

递归锁是一把锁,锁上有记录,只要acquire一次,锁上就计数1次, acquire2次,锁上就计数2次,

release1次,减一,

只要递归锁计数不为0,其他线程不能抢.

'''