线程类互斥锁

线程类互斥锁

死锁：两个或者两个以上的线程或者进程在执行的过程中 ， 因为资源竞争出现相互等待的情况

递归锁：这个锁可以加多次锁

from  threading import Thread , RLock
​
g = 0
​
def func():
    l.acquire()
    t.acquire()
    for i in range(100):
        global g
        g += 1
    print(g)
    t.release()
    l.release()
​
def fun():
    l.acquire()
    for i in range(100):
        global g
        g -= 1
    print(g)
    l.release()
​
if __name__ == '__main__':
    # 递归锁在内部会有一个变量，这个变量就会记录这个锁被创建多少次
    t = l = RLock()
    one = Thread(target=func)
    two = Thread(target=fun)
    one.start()
    two.start()

定时器

是指定在第n秒之后开始执行任务

from threading import Timer
import time
​
def func():
    print('线程执行之后的时间')
    print(time.strftime("%Y-%m-%d %H:%M:%S"))
​
if __name__ == '__main__':
    print('子线程启动前的时间')
    print(time.strftime("%Y-%m-%d %H:%M:%S"))
    t = Timer(3 , func)
    t.start()

Event

Event就是一个标志 ， True跟False ， 提供一个wait函数阻塞当前线程任务 ， 阻塞的状态是从False变成True

False表示阻塞 ， 初始化Event对象默认是False

is_set() , 返回event状态
wait()  状态值为False为阻塞 ， 默认是False
set()   设置event状态值为True 
clear() 恢复event的状态值为False

from threading import Event , Thread
import time
import random
​
# 红绿灯
def func_1():
    while 1:
        # 让任务设置为False
        e.clear()
        print('红灯亮起')
        # 模拟红绿灯的等待时间
        time.sleep(3)
        # 将程序设置通行True
        e.set()
        print('绿灯亮起')
        time.sleep(2)
​
# 设置行人
def func_2(name):
    while 1:
        # 判断是否可以通行，
        if e.is_set():
            print(f'{name}行人正在通行')
            break
        else:
            print(f'{name}正在等待')
            e.wait()
​
​
if __name__ == '__main__':
    # 设置Event对象
    e = Event()
    # 设置启动红绿灯的线程
    t = Thread(target=func_1)
    t.start()
​
    for i in range(10):
        # 模拟行人到达路边的情况
        time.sleep(random.randint(0,3))
        p = Thread(target=func_2 , args=(f'Tom{i}号',))
        p.start()