python多執行緒程式設計3: 使用互斥鎖同步線程

問題的提出

上一節的例子中，每個執行緒互相獨立，彼此之間沒有任何關係。現在假設這樣一個例子：有一個全域的計數num，每個執行緒取得這個全域的數，根據num進行一些處理，然後將num加1。很容易寫出這樣的程式碼：

# encoding: UTF-8
import threading
import time
  
class MyThread(threading.Thread):
    def run(self):
        global num
        time.sleep(1)
        num = num+1
        msg = self.name+' set num to '+str(num)
        print msg
num = 0
def test():
    for i in range(5):
        t = MyThread()
        t.start()
if __name__ == '__main__':
    test()

但是運行結果是不正確的：

Thread-5 set num to 2

Thread-3 set num to 3

Thread-1 set num to 5

Thread-4 set num to 4

問題產生的原因就是沒有控制多個執行緒對同一資源的訪問，對資料造成破壞，使得執行緒運行的結果不可預期。這種現象稱為「線程不安全」。

互斥鎖同步

上面的例子引出了多執行緒程式設計最常見的問題：資料共享。當多個執行緒都修改某一個共享資料的時候，就需要進行同步控制。

執行緒同步能夠確保多個執行緒安全存取競爭資源，最簡單的同步機制是引入互斥鎖。互斥鎖為資源引入一個狀態：鎖定/非鎖定。某個執行緒要更改共享資料時，先將其鎖定，此時資源的狀態為“鎖定”，其他執行緒不能更改；直到該執行緒釋放資源，將資源的狀態變成“非鎖定”，其他的執行緒才能再次鎖定該資源。互斥鎖保證了每次只有一個執行緒進行寫入操作，從而保證了多執行緒情況下資料的正確性。

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

#創建鎖

mutex = threading.Lock()

#鎖定

mutex.acquire([time mutex.release()

其中，鎖定方法acquire可以有一個超時時間的可選參數timeout。如果設定了timeout，則在逾時後透過返回值可以判斷是否得到了鎖，從而可以進行一些其他的處理。

使用互斥鎖實現上面的範例的程式碼如下：

import threading
import time
  
class MyThread(threading.Thread):
    def run(self):
        global num
        time.sleep(1)
  
        if mutex.acquire(1): 
            num = num+1
            msg = self.name+' set num to '+str(num)
            print msg
            mutex.release()
num = 0
mutex = threading.Lock()
def test():
    for i in range(5):
        t = MyThread()
        t.start()
if __name__ == '__main__':
    test()

運行結果：

Thread-3 set num to 1

Thread-4 set num to 2

Thread to 5% num to 2

Thread-2 set num to 4

Thread-1 set num to 5

可以看到，加入互斥鎖後，運行結果與預期相符。

同步阻塞

當一個執行緒呼叫鎖定的acquire()方法取得鎖定時，鎖定就進入「locked」狀態。每次只有一個線程可以獲得鎖。如果此時另一個執行緒試圖取得這個鎖，則該執行緒就會變成「blocked」狀態，稱為「同步阻塞」（請參閱多執行緒的基本概念）。

直到擁有鎖的執行緒呼叫鎖的release()方法釋放鎖之後，鎖進入「unlocked」狀態。執行緒調度程序從處於同步阻塞狀態的執行緒中選擇一個來獲得鎖，並使得該執行緒進入運行（running）狀態。

互斥鎖最基本的內容就是這些，下一節將討論可重入鎖（RLock)和死鎖問題。