Python threading模組中lock與Rlock的使用詳細講解

2022-10-14 14:01:47

前言

在使用多執行緒的應用下，如何保證執行緒安全，以及執行緒之間的同步，或者存取共用變數等問題是十分棘手的問題，也是使用多執行緒下面臨的問題，如果處理不好，會帶來較嚴重的後果，使用python多執行緒中提供Lock 、Rlock 、Semaphore 、Event 、Condition 用來保證執行緒之間的同步，後者保證存取共用變數的互斥問題。

Lock & RLock：互斥鎖，用來保證多執行緒存取共用變數的問題
Semaphore物件：Lock互斥鎖的加強版，可以被多個執行緒同時擁有，而Lock只能被某一個執行緒同時擁有。
Event物件：它是執行緒間通訊的方式，相當於訊號，一個執行緒可以給另外一個執行緒傳送訊號後讓其執行操作。
Condition物件：其可以在某些事件觸發或者達到特定的條件後才處理資料

1、Lock(互斥鎖)

請求鎖定 — 進入鎖定池等待 — — 獲取鎖 — 已鎖定— — 釋放鎖

Lock（指令鎖）是可用的最低階的同步指令。Lock處於鎖定狀態時，不被特定的執行緒擁有。Lock包含兩種狀態——鎖定和非鎖定，以及兩個基本的方法。

可以認為Lock有一個鎖定池，當執行緒請求鎖定時，將執行緒至於池中，直到獲得鎖定後出池。池中的執行緒處於狀態圖中的同步阻塞狀態。

構造方法：mylock = Threading.Lock( )

實體方法：

acquire([timeout]): 使執行緒進入同步阻塞狀態，嘗試獲得鎖定。
release(): 釋放鎖。使用前執行緒必須已獲得鎖定，否則將丟擲異常。

範例一（未使用鎖）：

import threading
import time
num = 0
def show(arg):
    global num
    time.sleep(1)
    num +=1
    print('bb :{}'.format(num))
for i in range(5):
    t = threading.Thread(target=show, args=(i,))  # 注意傳入引數後一定要有【，】逗號
    t.start()
print('main thread stop')

main thread stop
bb :1
bb :2
bb :3bb :4
bb :5

範例二（使用鎖）

import threading
import time
num = 0
lock = threading.RLock()
# 呼叫acquire([timeout])時，執行緒將一直阻塞，
# 直到獲得鎖定或者直到timeout秒後（timeout引數可選）。
# 返回是否獲得鎖。
def Func():
    lock.acquire()
    global num
    num += 1
    time.sleep(1)
    print(num)
    lock.release()
for i in range(10):
    t = threading.Thread(target=Func)
    t.start()

1
2
3
4
5
6
7
8
9
10
#可以看出，全域性變數在在每次被呼叫時都要獲得鎖，才能操作，因此保證了共用資料的安全性

對於Lock物件而言，如果一個執行緒連續兩次release，使得執行緒死鎖。所以Lock不常用，一般採用Rlock進行執行緒鎖的設定。

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

2、RLock(可重入鎖)

RLock（可重入鎖）是一個可以被同一個執行緒請求多次的同步指令。RLock使用了“擁有的執行緒”和“遞迴等級”的概念，處於鎖定狀態時，RLock被某個執行緒擁有。擁有RLock的執行緒可以再次呼叫acquire()，釋放鎖時需要呼叫release()相同次數。可以認為RLock包含一個鎖定池和一個初始值為0的計數器，每次成功呼叫 acquire()/release()，計數器將+1/-1，為0時鎖處於未鎖定狀態。

構造方法：mylock = Threading.RLock()
實體方法：acquire([timeout])/release(): 跟Lock差不多。

範例解決死鎖，呼叫相同次數的acquire和release，保證成對出現

'''
尋找有志同道合的小夥伴，互幫互助,群裡還有不錯的視訊學習教學和PDF電子書！
'''
import threading
rLock = threading.RLock()  #RLock物件
rLock.acquire()
rLock.acquire() #在同一執行緒內，程式不會堵塞。
rLock.release()
rLock.release()
print(rLock.acquire())

詳細範例：

import threading
mylock = threading.RLock()
num = 0
class WorkThread(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.t_name = name
    def run(self):
        global num
        while True:
            mylock.acquire()
            print('n%s locked, number: %d' % (self.t_name, num))
            if num >= 2:
                mylock.release()
                print('n%s released, number: %d' % (self.t_name, num))
                break
            num += 1
            print('n%s released, number: %d' % (self.t_name, num))
            mylock.release()
def test():
    thread1 = WorkThread('A-Worker')
    thread2 = WorkThread('B-Worker')
    thread1.start()
    thread2.start()
if __name__ == '__main__':
    test()

A-Worker locked, number: 0

A-Worker released, number: 1

A-Worker locked, number: 1

A-Worker released, number: 2

A-Worker locked, number: 2

A-Worker released, number: 2

B-Worker locked, number: 2

B-Worker released, number: 2

到此這篇關於Python threading模組中lock與Rlock的使用詳細講解的文章就介紹到這了,更多相關Python threading內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！

Python threading模組中lock與Rlock的使用詳細講解

目錄

前言

1、Lock(互斥鎖)

2、RLock(可重入鎖)

熱門文章