什么是Python線程互斥鎖

什么是Python線程互斥鎖？很多新手對此不是很清楚，為了幫助大家解決這個難題，下面小編將為大家詳細講解，有這方面需求的人可以來學習下，希望你能有所收獲。

線程互斥鎖

1.線程互斥鎖介紹

當多個線程幾乎同時修改某一個共享數據的時候，需要進行同步控制，線程同步能夠保證多個線程安全訪問競爭資源，最簡單的同步機制是引入互斥鎖。

互斥鎖為資源引入一個狀態：鎖定/非鎖定

某個線程要更改共享數據時，先將其鎖定，此時資源的狀態為“鎖定”，其他線程不能更改；直到該線程釋放資源，將資源的狀態變成“非鎖定”，其他的線程才能再次鎖定該資源。互斥鎖保證了每次只有一個線程進行寫入操作，從而保證了多線程情況下數據的正確性。

threading模塊中定義了Lock類，可以方便的處理鎖定：

#創建鎖
mutex = threading.Lock()
#鎖定
mutex.acquire([blocking])
#釋放
mutex.release()

其中，鎖定方法acquire可以有一個blocking參數。

如果設定blocking為True，則當前線程會堵塞，直到獲取到這個鎖為止（如果沒有指定，那么默認為True）。

如果設定blocking為False，則當前線程不會堵塞。

使用互斥鎖實現上面的例子的代碼如下：

from threading import Thread, Lock
import time
g_num = 0
def test1():
    global g_num
    for i in range(1000000):
        #True表示堵塞 即如果這個鎖在上鎖之前已經被上鎖了，那么這個線程會在這里一直等待到解鎖為止 
        #False表示非堵塞，即不管本次調用能夠成功上鎖，都不會卡在這,而是繼續執行下面的代碼
        mutexFlag = mutex.acquire(True) 
        if mutexFlag:#鎖住
            g_num += 1
            mutex.release()#解鎖
    print("---test1---g_num=%d"%g_num)
def test2():
    global g_num
    for i in range(1000000):
        mutexFlag = mutex.acquire(True) #True表示堵塞
        if mutexFlag:#鎖住
            g_num += 1
            mutex.release()#解鎖
    print("---test2---g_num=%d"%g_num)
#創建一個互斥鎖
#這個所默認是未上鎖的狀態
mutex = Lock()
p1 = Thread(target=test1)
p1.start()
p2 = Thread(target=test2)
p2.start()
time.sleep(5)
print("---g_num=%d---"%g_num)

運行結果為：

---test1---g_num=1942922
---test2---g_num=2000000
---g_num=2000000---

2.上鎖解鎖過程

當一個線程調用鎖的acquire()方法獲得鎖時，鎖就進入“locked”狀態。

每次只有一個線程可以獲得鎖。如果此時另一個線程試圖獲得這個鎖，該線程就會變為“blocked”狀態，稱為“阻塞”，直到擁有鎖的線程調用鎖的release()方法釋放鎖之后，鎖進入“unlocked”狀態。

線程調度程序從處于同步阻塞狀態的線程中選擇一個來獲得鎖，并使得該線程進入運行（running）狀態。

鎖的好處：

確保了某段關鍵代碼只能由一個線程從頭到尾完整地執行

鎖的壞處：

阻止了多線程并發執行，包含鎖的某段代碼實際上只能以單線程模式執行，效率就大大地下降了

由于可以存在多個鎖，不同的線程持有不同的鎖，并試圖獲取對方持有的鎖時，可能會造成死鎖

3.死鎖

在線程間共享多個資源的時候，如果兩個線程分別占有一部分資源并且同時等待對方的資源，就會造成死鎖。

盡管死鎖很少發生，但一旦發生就會造成應用的停止響應。下面看一個死鎖的例子：

#coding=utf-8
import threading
import time
class MyThread1(threading.Thread):
    def run(self):
        if mutexA.acquire():
            print(self.name+'----do1---up----')
            time.sleep(1)
            if mutexB.acquire():
                print(self.name+'----do1---down----')
                mutexB.release()
            mutexA.release()
class MyThread2(threading.Thread):
    def run(self):
        if mutexB.acquire():
            print(self.name+'----do2---up----')
            time.sleep(1)
            if mutexA.acquire():
                print(self.name+'----do2---down----')
                mutexA.release()
            mutexB.release()
mutexA = threading.Lock()
mutexB = threading.Lock()
if __name__ == '__main__':
    t1 = MyThread1()
    t2 = MyThread2()
    t1.start()
    t2.start()

運行結果為：

Thread-1----do1---up----
Thread-2----do2---up----

此時已經進入到了死鎖狀態

4.避免死鎖

程序設計時要盡量避免（銀行家算法）

添加超時時間等

看完上述內容是否對您有幫助呢？如果還想對相關知識有進一步的了解或閱讀更多相關文章，請關注億速云行業資訊頻道，感謝您對億速云的支持。