快捷導(dǎo)航

Python并行編程多線程鎖機(jī)制Lock與RLock實(shí)現(xiàn)線程同步

更新時間：2022年07月01日 15:03:54 作者：若數(shù)

這篇文章主要為大家介紹了Python并行編程多線程鎖機(jī)制Lock與RLock實(shí)現(xiàn)線程同步示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪

什么是鎖機(jī)制？

要回答這個問題，我們需要知道為什么需要使用鎖機(jī)制。前面我們談到一個進(jìn)程內(nèi)的多個線程的某些資源是共享的，這也是線程的一大優(yōu)勢，但是也隨之帶來一個問題，即當(dāng)兩個及兩個以上的線程同時訪問共享資源時，如果此時沒有預(yù)設(shè)對應(yīng)的同步機(jī)制，就可能帶來同一時刻多個線程同時訪問同一個共享資源，即出現(xiàn)競態(tài)，多數(shù)情況下我們是不希望出現(xiàn)這樣的情況的，那么怎么避免呢？

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)

運(yùn)行截圖如下：

運(yùn)行結(jié)果

當(dāng)我們多次運(yùn)行時，可以看到最終的結(jié)果都幾乎不等于我們期待的值即resource初始值0。

為什么呢？原因就是因?yàn)?+= 和 -=并不是原子操作。

可以使用dis模塊查看字節(jié)碼：

import dis
def add(total):
    total += 1
def desc(total):
    total -= 1
total = 0
print(dis.dis(add))
print(dis.dis(desc))
# 運(yùn)行結(jié)果：
#   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)

運(yùn)行截圖如下：

運(yùn)行結(jié)果

從運(yùn)行結(jié)果可以看到，不論我們運(yùn)行多少次改代碼，其resource的值都為初始值0，這就是Lock()的功勞，即它可以將某一時刻的訪問限定在單個線程或者單個類型的線程上，在訪問鎖定的共享資源時，必須要現(xiàn)獲取對應(yīng)的鎖才能訪問，即要等待其他線程釋放資源，即resource_lock.release()當(dāng)然為了防止我們對某個資源鎖定后，忘記釋放鎖，導(dǎo)致死鎖，我們可以利用上下文管理器管理鎖實(shí)現(xiàn)同樣的效果：

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()的區(qū)別

我們需要知道Lock()作為一個基本的鎖對象，一次只能一個鎖定，其余鎖請求，需等待鎖釋放后才能獲取，否則會發(fā)生死鎖：

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內(nèi)部維護(hù)著一個Lock和一個counter變量，counter記錄了acquire的次數(shù)，從而使得資源可以被多次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()

以上就是Python并行編程多線程鎖機(jī)制Lock與RLock實(shí)現(xiàn)線程同步的詳細(xì)內(nèi)容，更多關(guān)于Python鎖Lock RLock線程同步的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: