python守护线程、互斥锁、递归锁的基本概念与使用

无论是进程还是线程，都遵循：守护xxx会等待主xxx运行完毕后被销毁
需要强调的是：运行完毕并非终止运行

守护线程

• ！！！ 如果子线程开启了守护模式，那么主线程运行完后立即干死子线程、而主线程要等未加守护的线程运行完毕

from threading import Thread
import time

def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")

if __name__ == '__main__':
    t1=Thread(target=foo)
    t2=Thread(target=bar)

    t2.daemon = True  # 只给t2加上守护
    t1.start()
    t2.start()
    print("main-------")
    # 主线程会等t1运行完了就死掉，所以t2会跟着死掉，即便只打印 一半
    # 123
    # 456
    # main-------
    # end123

---

递归锁 RLock

原理和进程互斥锁一样，不过线程版共享该进程下的数据

递归锁：可以连续acquire多次， 每次acquire计数器 +1，只要计数不为0就不能被其他线程抢到

from threading import Thread,RLock
import time

mutexA=mutexB=RLock() #一个线程拿到锁，counter加1,该线程内又碰到加锁的情况，则counter继续加1，这期间所有其他线程都只能等待，等待该线程释放所有锁，即counter递减到0为止

class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()
    def func1(self):
        mutexA.acquire()
        print('\033[41m%s 拿到A锁\033[0m' %self.name)

        mutexB.acquire()
        print('\033[42m%s 拿到B锁\033[0m' %self.name)
        mutexB.release()

        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print('\033[43m%s 拿到B锁\033[0m' %self.name)
        time.sleep(2)

        mutexA.acquire()
        print('\033[44m%s 拿到A锁\033[0m' %self.name)
        mutexA.release()

        mutexB.release()

if __name__ == '__main__':
    for i in range(10):
        t=MyThread()
        t.start()