Python並行編程(二)：多線程鎖機制利用Lock與RLock實現線程同步

什麼是鎖機制？

要回答這個問題，咱們須要知道爲何須要使用鎖機制。前面咱們談到一個進程內的多個線程的某些資源是共享的，這也是線程的一大優點，可是也隨之帶來一個問題，即當兩個及兩個以上的線程同時訪問共享資源時，若是此時沒有預設對應的同步機制，就可能帶來同一時刻多個線程同時訪問同一個共享資源，即出現競態，多數狀況下咱們是不但願出現這樣的狀況的，那麼怎麼避免呢？

Lock() 管理線程

先看一段代碼：

import threading
import time
resource = 0

count = 1000000

resource_lock = threading.Lock()


def increment():
    global resource
    for i in range(count):
        resource += 1


def decerment():
    global resource
    for i in range(count):
        resource -= 1


increment_thread = threading.Thread(target=increment)
decerment_thread = threading.Thread(target=decerment)

increment_thread.start()
decerment_thread.start()

increment_thread.join()
decerment_thread.join()

print(resource)

複製代碼

運行截圖以下：

當咱們屢次運行時，能夠看到最終的結果都幾乎不等於咱們期待的值即 resource初始值 0。

爲何呢？ 緣由就是由於 += 和 -=並非原子操做。可使用dis模塊查看字節碼：

import dis
def add(total):
    total += 1
def desc(total):
    total -= 1
total = 0
print(dis.dis(add))
print(dis.dis(desc))
# 運行結果：
# 3 0 LOAD_FAST 0 (total)
# 3 LOAD_CONST 1 (1)
# 6 INPLACE_ADD
# 7 STORE_FAST 0 (total)
# 10 LOAD_CONST 0 (None)
# 13 RETURN_VALUE
# None
# 5 0 LOAD_FAST 0 (total)
# 3 LOAD_CONST 1 (1)
# 6 INPLACE_SUBTRACT
# 7 STORE_FAST 0 (total)
# 10 LOAD_CONST 0 (None)
# 13 RETURN_VALUE
# None

複製代碼

那麼如何保證初始值爲0呢？ 咱們能夠利用Lock（），代碼以下：

import threading
import time
resource = 0

count = 1000000

resource_lock = threading.Lock()


def increment():
    global resource
    for i in range(count):
        resource_lock.acquire()
        resource += 1
        resource_lock.release()


def decerment():
    global resource
    for i in range(count):
        resource_lock.acquire()
        resource -= 1
        resource_lock.release()


increment_thread = threading.Thread(target=increment)
decerment_thread = threading.Thread(target=decerment)

increment_thread.start()
decerment_thread.start()

increment_thread.join()
decerment_thread.join()

print(resource)

複製代碼

運行截圖以下：

從運行結果能夠看到，不論咱們運行多少次改代碼，其 resource的值都爲初始值 0， 這就是 Lock()的功勞，即它能夠將某一時刻的訪問限定在單個線程或者單個類型的線程上，在訪問鎖定的共享資源時，必需要現獲取對應的鎖才能訪問，即要等待其餘線程釋放資源，即 resource_lock.release() 固然爲了防止咱們對某個資源鎖定後，忘記釋放鎖，致使死鎖，咱們能夠利用上下文管理器管理鎖實現一樣的效果：

import threading
import time
resource = 0

count = 1000000

resource_lock = threading.Lock()


def increment():
    global resource
    for i in range(count):
        with resource_lock:
                resource += 1


def decerment():
    global resource
    for i in range(count):
        with resource_lock:
                resource -= 1
        


increment_thread = threading.Thread(target=increment)
decerment_thread = threading.Thread(target=decerment)

increment_thread.start()
decerment_thread.start()
複製代碼

RLock() 與Lock()的區別

咱們須要知道Lock()做爲一個基本的鎖對象，一次只能一個鎖定，其他鎖請求，需等待鎖釋放後才能獲取，不然會發生死鎖：

import threading
resource.lock = threading.lock()

resource = 0

resource.lock.acquire()
resource.lock.acquire()
resource += 1
resource.lock.release()
resource.lock.release()
複製代碼

爲解決同一線程中不能屢次請求同一資源的問題，python提供了「可重入鎖」：threading.RLock，RLock內部維護着一個Lock和一個counter變量，counter記錄了acquire的次數，從而使得資源能夠被屢次acquire。直到一個線程全部的acquire都被release，其餘的線程才能得到資源 。用法和threading.Lock類相同，即好比遞歸鎖的使用：

import threading
lock = threading.RLock()
def dosomething(lock):
    lock.acquire()
    # do something
    lock.release()
    
lock.acquire()
dosomething(lock)
lock.release()
複製代碼