线程互斥锁

#coding=utf-8
import threading

num=0

#创建互斥锁
lock=threading.Lock()

'''
在两个线程中都调用上锁的方法，则这两个线程就会抢着上锁，
如果有1方成功上锁，那么导致另外一方会堵塞（一直等待）直到这个锁被解开
'''
def fun1():
    global num
    lock.acquire()  #上锁     但此种方式上锁会导致循环被锁定，不利于资源使用
    for i in range(100000):
        num+=1
    print('运行fun1函数num的值：{}'.format(num))
    lock.release()  #解锁

def fun2():
    global num
    lock.acquire()  #上锁
    for i in range(100000):
        num+=1
    print('运行fun2函数num的值：{}'.format(num))
    lock.release()  #解锁

if __name__=='__main__':
    #创建线程
    t1=threading.Thread(target=fun1)
    t2=threading.Thread(target=fun2)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
结果：
运行fun1函数num的值：100000
运行fun2函数num的值：200000

互斥锁改进

#coding=utf-8
from threading import *

num=0

#创建互斥锁
lock=Lock()

'''
在两个线程中都调用上锁的方法，则这两个线程就会抢着上锁，
如果有1方成功上锁，那么导致另外一方会堵塞（一直等待）直到这个锁被解开
'''
def fun1():
    global num

    for i in range(100000):
        lock.acquire()  #上锁    优化上锁
        num+=1
        lock.release()  #解锁
    print('运行fun1函数num的值：{}'.format(num))


def fun2():
    global num

    for i in range(100000):
        lock.acquire()  #上锁    优化上锁，这种效率较高
        num+=1
        lock.release()  #解锁
    print('运行fun2函数num的值：{}'.format(num))


if __name__=='__main__':
    #创建线程
    t1=Thread(target=fun1)
    t2=Thread(target=fun2)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
结果：fun1每次运行的结果不一致，但是能保证fun2最后的结果一定是200000
运行fun1函数num的值：155791
运行fun2函数num的值：200000