守护进程，互斥锁，死锁现象以及信号量

1 守护线程

from threading import Thread,current_thread
import time

def task():
    print('%s is running' % current_thread().name)
    time.sleep(3)
    print('%s is done' % current_thread().name)

if __name__ == '__main__':
    t1=Thread(target=task,name='第一个线程')
    t1.daemon = True
    t1.start()
    # time.sleep(5)
    t1.join()


print('主线程')

多个子线程的守护线程

from threading import Thread
import time
def foo():
    print(123)
    time.sleep(5)
    print("end123")

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

if __name__ == '__main__':

    t1=Thread(target=foo)
    t2=Thread(target=bar)

    t1.daemon=True
    t1.start()
    t2.start()
    print("main-------")

总结：

主进程：执行完代码就结束。

主线程：所有子线程结束才结束。

总结：只要进程内没有可执行的代码守护就结束。

2 互斥锁

注意一点：线程互斥锁可以放在全局名称空间，因为他们在同一个进程内，共享资源。

from threading import Thread,Lock
import time

mutex=Lock()
x=100

def task():
    global x
    mutex.acquire()
    temp=x
    time.sleep(0.1)
    x=temp-1
    mutex.release()

if __name__ == '__main__':
    start=time.time()
    t_l=[]
    for i in range(100):
        t=Thread(target=task)
        t_l.append(t)
        t.start()
    for t in t_l:
        t.join()

    print('主',x)    #0
print(time.time()-start)

3 死锁现象及解决方案 ——》递归锁
注意点：mutex=Rlock 可以连续acquire，但只有其引用计数为0，其他线程才可以使用。

from threading import Thread,Lock,RLock
import time

# mutexA=Lock()  #如果用Lock（互斥锁），会发生死锁现象
# mutexB=Lock()

mutexA=mutexB=RLock()  #是一把锁，可连续acqruie，但只有其上的计数为0时其他线程才可对其调用

class MyThread(Thread):
    def run(self):
        self.f1()
        self.f2()

    def f1(self):
        mutexA.acquire()
        print('%s 拿到了A锁' %self.name)

        mutexB.acquire()
        print('%s 拿到了B锁' %self.name)
        mutexB.release()

        mutexA.release()

    def f2(self):
        mutexB.acquire()
        print('%s 拿到了B锁' %self.name)
        time.sleep(0.1)

        mutexA.acquire()
        print('%s 拿到了A锁' %self.name)
        mutexA.release()

        mutexB.release()


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

print('主')

4 信号量

# from multiprocessing import Semaphore #进程和线程中皆可导入Semaphore模块
from threading import Thread,Semaphore,current_thread
import time,random

sm=Semaphore(5)  #5把钥匙，即同时可以5个对象进行执行

def go_wc():
    sm.acquire()
    print('%s 上厕所ing' %current_thread().getName())
    time.sleep(random.randint(1,3))
    sm.release()

if __name__ == '__main__':
    for i in range(23):
        t=Thread(target=go_wc)
        t.start()