Python3 从零单排27_锁&信号量&Event&定时器

　　1.死锁

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

from threading import Thread,Lock
import time

mutexA=Lock()
mutexB=Lock()

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()
        print('%s 释放了B锁' % self.name)
        mutexA.release()
        print('%s 释放了A锁' % self.name)

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

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

 

　　2.递归锁

　　互斥锁只能acquire一次

　　递归锁:可以连续acquire多次，每acquire一次计数器+1，只有计数为0时，才能被抢到acquire

# 互斥锁只能acquire一次
from threading import Thread,Lock

mutexA=Lock()

mutexA.acquire()
mutexA.acquire()  # 程序卡在这里了


# 递归锁:可以连续acquire多次，每acquire一次计数器+1，只有计数为0时，才能被抢到acquire
from threading import Thread,RLock
import time

mutexB=mutexA=RLock()

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()
        print('%s 释放了B锁' % self.name)
        mutexA.release()
        print('%s 释放了A锁' % self.name)

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

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

 

　　3.信号量

　　互斥锁或者递归锁都只能在一个时间点为同一个线程服务，一个萝卜一个坑。但是多个萝卜可以同时占用多个坑就没办法了，这里就用到了信号量。
　　信号量，体现在量，批量，也就是说支持同一时间点可以给多个线程用，原理实际是计数器，占用一个-1，释放一个+1，计数不能小于0。
　　Semaphore管理一个内置的计数器，每当调用acquire()时内置计数器-1；调用release() 时内置计数器+1；
　　计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。

from threading import Thread, Semaphore, current_thread
import time, random
se = Semaphore(3)  # 最多只能同时占用3次


def toilet():
    with se:  # 用法同文件操作，将打开和关闭合并在with语法里。  等价于  se.acquire()  se.release()
        print("%s go in" % current_thread().getName())
        time.sleep(random.randint(1, 3))


if __name__ == "__main__":
    for i in range(10):
        t = Thread(target=toilet)
        t.start()

 

　　4.Event

　　线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。
　　为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。
　　在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。
　　一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行

　　event.isSet()：返回event的状态值；
　　event.wait()：如果 event.isSet()==False将阻塞线程；
　　event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度；
　　event.clear()：恢复event的状态值为False。

from threading import Thread, Event
import time
e = Event()

def student(name):
    print("%s is learning" % name)
    e.wait(3)  # 一直等event.set()，最多等3秒
    print("%s is playing" % name)

def teacher(name):
    print("%s is teaching" % name)
    time.sleep(6)
    print("%s said class over!" % name)
    e.set()


if __name__ == "__main__":
    for i in range(10):
        s = Thread(target=student, args=(i,))
        s.start()
    t = Thread(target=teacher)
    t.start()

 

　　5.定时器  定时执行任务

from threading import Timer


def toilet(name):
    print("%s go in" % name)


if __name__ == "__main__":
    for i in range(10):
        t = Timer(3, toilet, args=("xg %s" % i,))  # 3秒后 启动toilet
        t.start()


from threading import Timer
import random

class Code:
    def __init__(self):
        self.make_cache()

    def make_cache(self,interval=5):
        self.cache=self.make_code()
        print(self.cache)
        self.t=Timer(interval,self.make_cache)
        self.t.start()

    def make_code(self,n=4):
        res=''
        for i in range(n):
            s1=str(random.randint(0,9))
            s2=chr(random.randint(65,90))
            res+=random.choice([s1,s2])
        return res

    def check(self):
        while True:
            code=input('请输入你的验证码>>: ').strip()
            if code.upper() == self.cache:
                print('验证码输入正确')
                self.t.cancel()
                break


obj=Code()
obj.check()