互斥锁与递归锁

# 一般进程中，我们锁用的少，因为我们进程之间通信，很少会使用IPC中的管道、队列、Manager这些东西，而是使用一些中间件，而在这些中间件中，已经帮我们实现了进程之间锁的功能，访问消息中间件是不需要加锁的

# 线程锁
    # Lock互斥锁会存在死锁问题，需要编码者注意
    # RLock递归锁

# 互斥锁
# from threading import Lock
# from threading import Thread
# import time
#
# def my_thread1(lock):
#     lock.acquire()  # 上锁
#     while True:
#         time.sleep(1)
#
# lock = Lock()
# t = Thread(target=my_thread1, args=(lock,))
# t.start()
#
# lock.acquire()  # 子线程上锁后未解锁，这里会阻塞
# print(123)

#
# from threading import Lock
# from threading import Thread
# import time
#
# def my_thread1(lock):
#     global n
#     lock.acquire()  # 上锁
#     temp = n
#     time.sleep(0.2)
#     n = temp - 1
#     lock.release()  # 解决锁
#
#
# if __name__ == '__main__':
#     n = 10
#     t_lst = []
#     lock = Lock()
#     for i in range(10):
#         t = Thread(target=my_thread1, args=(lock,))
#         t_lst.append(t)
#         t.start()
#     for t in t_lst:
#         t.join()
#     print(n)


# 递归锁
    # 存在锁深度，一个线程每上一次锁都会向里放一把锁，另一个线程想要拿递归锁，必须等待之前的线程将递归锁全部解锁

from threading import RLock
from threading import Thread
import time

def my_thread(rlock):
    rlock.acquire() # 因主线程上了四次锁，需要主线程解四次锁后这里才能拿到锁，才能执行到print

    print(44444)

if __name__ == '__main__':
    rlock = RLock()
    rlock.acquire()
    rlock.acquire()
    rlock.acquire()
    rlock.acquire()
    print(3333) # 3333

    # rlock.release()
    # rlock.release()
    # rlock.release()
    # rlock.release()
    t = Thread(target=my_thread, args=(rlock,))
    t.start()
    t.join()
    print(66666)