執行緒及其互斥鎖：

執行緒共享全域性變數，但是當多個執行緒對同一個變數進行操作時，會出現混亂，為了解決這個問題，我們可以用輪詢以及互斥鎖的方法，對多個執行緒實現同步控制。

互斥鎖的工作原理：

當某個執行緒要改共享資料時，先將其鎖定，此時資源狀態為“鎖定”，其他執行緒不能更改；直到該執行緒釋放資源，互斥鎖保證了每次只有一個執行緒進行讀寫操作，從而保證了多執行緒情況下資料的正確性。

注意：互斥鎖在運用時，必須在每個執行緒中都上鎖，這樣多個執行緒才會搶著上鎖。

死鎖的解決辦法：

設定超時時間：在加鎖時設定一定的時間，如果時間到了，還不滿足時間，則預設會不加鎖執行。

在設計時利用銀行家演算法

建立互斥鎖的步驟：

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()