递归锁(RLock)

'''递归锁(RLock)'''
import threading
import time

# class MyThread(threading.Thread):
#  def actionA(self):
#     A.acquire()
#     print(self.name, 'gotA', time.ctime())
#     time.sleep(2)
#
#     B.acquire()
#     print(self.name, 'gotB', time.ctime())
#     time.sleep(1)
#
#     B.release()
#     A.release()
#
#  def actionB(self):
#     B.acquire()
#     print(self.name, 'gotB', time.ctime())
#     time.sleep(2)
#
#     A.acquire()
#     print(self.name, 'gotA', time.ctime())
#     time.sleep(1)
#
#     A.release()
#     B.release()
#
#  def run(self):
#     '''继承的方式，必须重写run方法'''
#     self.actionA()
#     time.sleep(1)
#     self.actionB()
#
# if __name__ == '__main__':
#  A = threading.Lock()
#  B = threading.Lock()
#  l = []
#
#  for i in range(5):
#     t = MyThread()
#     t.start()
#     l.append(t)
#
#  for i in l:
#     i.join()
#
#  print('ending...')
# 死锁：第一个线程执行完actionA时，把A和B两把锁也释放了，而且第二个线程也开始执行actionA，第一个线程则执行actionB；第一个线程拿到了B锁，第二个线程
# 拿到了A锁，第一个线程需要拿到A锁，而第二个线程也需要拿到B锁，此时就出现了死锁的现象，程序卡住无法继续往下执行


class MyThread_1(threading.Thread):
   def actionA(self):
      r_lock.acquire() # count=1
      print(self.name, 'gotA', time.ctime())
      time.sleep(2)

      r_lock.acquire() # count=2
      print(self.name, 'gotB', time.ctime())
      time.sleep(1)

      r_lock.release() # count=1
      r_lock.release() # count=0

   def actionB(self):
      r_lock.acquire()
      print(self.name, 'gotB', time.ctime())
      time.sleep(2)

      r_lock.acquire()
      print(self.name, 'gotA', time.ctime())
      time.sleep(1)

      r_lock.release()
      r_lock.release()

   def run(self):
      self.actionA()
      self.actionB()

if __name__ == '__main__':
   r_lock = threading.RLock() # RLock()，内部实现以count计数为准，当count大于0，那么锁无法被抢夺
   l = []

   for i in range(5):
      t = MyThread_1()
      t.start()
      l.append(t)

   for i in l:
      i.join()

   print('ending...')
# 当一个线程在执行中使用了RLock()锁，那么锁没有被完全释放是不会出现被抢占的情况；比如：第一个线程执行完actionA后，把锁释放完了，此时本还需要
# 继续执行actionB，可是锁释放完毕没有谁在用，那么剩下的4个线程都可以去争夺这个锁去执行，所以每当线程上了RLock()锁后，只有当这个线程释放完RLock()
# 锁才能进行线程的切换