线程及其互斥锁：

线程及其互斥锁：

线程共享全局变量，但是当多个线程对同一个变量进行操作时，会出现混乱，为了解决这个问题，我们可以用轮询以及互斥锁的方法，对多个线程实现同步控制。

互斥锁的工作原理：

当某个线程要改共享数据时，先将其锁定，此时资源状态为“锁定”，其他线程不能更改；直到该线程释放资源，互斥锁保证了每次只有一个线程进行读写操作，从而保证了多线程情况下数据的正确性。

注意：互斥锁在运用时，必须在每个线程中都上锁，这样多个线程才会抢着上锁。

死锁的解决办法：

设置超时时间：在加锁时设置一定的时间，如果时间到了，还不满足时间，则默认会不加锁执行。

在设计时利用银行家算法

创建互斥锁的步骤：

Mutex = threading.Lock() #创建锁对象

Mutdex.acquire(blocking)#锁定

Mutdex.release()#释放

方法一：轮询的方法

from threading import Thread

import time

num = 0

flag = False

 

def fun1():

    global num

    global flag

    if flag == False:

        for i in range(100000):

            num += 1

        flag = True

        print("fun1的结果：{}".format(num))

 

def fun2():

    global num

    while True:

        if flag == True:

            for i in range(100000):

                num += 1

            print('fun2的结果：%d' % num)

            break

 

thread1 = Thread(target=fun1)

thread2 = Thread(target=fun2)

thread1.start()

thread2.start()

方法二：互斥锁

from threading import Thread, Lock

import time

num = 0

lock = Lock()

def fun1():

    lock.acquire()

    global num

    for i in range(100000):

        num += 1

    print("fun1的结果：{}".format(num))

    lock.release()

 

def fun2():

    lock.acquire()

    global num

    for i in range(100000):

        num += 1

    print('fun2的结果：%d' % num)

    lock.release()

 

thread1 = Thread(target=fun1)

thread2 = Thread(target=fun2)

thread1.start()

thread2.start()