Python中的互斥锁和join的应用

一丧“人生大部分的时候，都挺无聊的”

先说互斥锁的作用：lock互斥锁实现防止全局变量的互相争抢
做一个不太形象的比喻，你买了一个杯子（进程），你想喝混合口味的果汁，但是要自己做（线程），两种口味的果汁的接水口离得有点远，你不能一起接，所以你先接A后接B（互斥锁）(原谅我这个理科生粗陋的比喻)

不过可以说互斥锁是一个伪多线程。使用互斥锁我们就一定要认识一个新的方法Lock

Lock的使用实例

import threading
num =0
lock = threading.Lock()#导入互斥锁
def work1(number):
    lock.acquire()#上锁
    global num
    for i in range(number):
        num+=1
    print(num)
    lock.release()#解锁
def work2(number):
    lock.acquire()#上锁
    global num
    for i in range(number):
        num+=1
    print(num)
    lock.release()#解锁
if __name__ == '__main__':
    t1 = threading.Thread(target=work1,args=(2333,))#args传值一定为元组所以用（值，）
    t2 = threading.Thread(target=work2, args=(2333,))
    t1.start()
    t2.start()

这就完了吗？当然没有
试想如果你在一个接口接果汁，另一个被其他人占用，怎么办？

timeout

timeout顾名思义，就是一个定时器，当时间到达timeout定的值后，自动结束线程，将空间交给后来者。
我们来看实例吧

import threading
num =0
lock = threading.Lock()#导入互斥锁
def work1(number):
    lock.acquire(timeout=1)#上锁,无论如何1s后结束此线程
    global num
    for i in range(number):
        num+=1
    print(num)
    lock.release()#解锁
def work2(number):
    lock.acquire(timeout=1)#上锁,无论如何1s后结束此线程
    global num
    for i in range(number):
        num+=1
    print(num)
    lock.release()#解锁
if __name__ == '__main__':
    t1 = threading.Thread(target=work1,args=(2333,))#args传值一定为元组所以用（值，）
    t2 = threading.Thread(target=work2, args=(2333,))
    t1.start()
    t2.start()

除了锁还有别的方法可以避免这个问题吗？有，当然有

join方法

join方法就是当线程A结束后执行线程B（摔杯，那还谈什么多线程啊，你这个太明显了啊）

import threading
# 全局变量join lock timeout=
num = 0
# 任务一：
def work1(number):
    global num
    for i in range(number):
        num += 1
    print('此时Num等于', num)
# 任务二：
def work2(number):
    global num
    for i in range(number):
        num += 1
    print('此时Num等于', num)
if __name__ == '__main__':
    t1 = threading.Thread(target=work1, args=(10000000,))
    t2 = threading.Thread(target=work2, args=(10000000,))
    t1.start()
    t1.join()#当t1结束后执行t2
    t2.start()