Python 中多線程主要有以下幾種類型的鎖：
.Lock：這是最基礎(chǔ)的鎖對象，不屬于任何線程，在Python中，它是一個同步原語對象。一次只有一個線程可以獲得鎖。如果一個線程試圖獲得一個已經(jīng)被其他線程拿著的鎖，那么這個線程就會被阻塞，直到擁有鎖的線程釋放。.RLock：可重入鎖（RLock），允許同一線程多次獲取鎖，但是每次獲取鎖都需要釋放，通常用于遞歸函數(shù)。如果使用Lock，那么在同一個線程多次獲取鎖時會產(chǎn)生死鎖。.：信號量，允許一定數(shù)量的線程同時獲取鎖。例如，如果你有一些資源，每次可以被5個線程同時訪問，那么你就可以使用一個初始化為5的信號量。.：有界信號量，與類似，但是在釋放鎖的時候，會檢查當(dāng)前的信號量的值是否超過了初始值，如果超過了會拋出一個異常。.：條件變量，允許一個或多個線程等待某個條件滿足，然后喚醒。.Event：事件對象。事件對象內(nèi)部有一個標(biāo)志位，初始為False。如果標(biāo)志位為True，wait()不做任何事情，如果標(biāo)志位為False，wait()會阻塞。可以通過set()來設(shè)置標(biāo)志位，clear()來清除標(biāo)志位。.Barrier：柵欄對象，允許一定數(shù)量的線程同步，直到所有線程都到達柵欄位置，才會全部釋放。
注意，在Python中，由于全局解釋器鎖（GIL）的存在，同一時刻只允許一個線程執(zhí)行Python字節(jié)碼，因此Python的多線程并不能實現(xiàn)真正的并行計算。如果需要進行并行計算，可以使用模塊，或者使用其他的并行計算框架，如.futures。
.Lock()：線程鎖，可用于同步多個線程對共享資源的訪問。 錯誤示范：
存在一個問題，就是在每次循環(huán)的時候都創(chuàng)建了一個新的鎖。這樣的話，每個鎖都是獨立的，它們之間不能保證對共享資源 counter 的互斥訪問，因此在多線程環(huán)境下，counter += 1 操作可能會出現(xiàn)競態(tài)條件，導(dǎo)致結(jié)果不是預(yù)期的 。
import threading
counter = 0 # 共享資源
def increment():
global counter
for _ in range(1000000):
with threading.Lock(): # 獲取線程鎖
counter += 1
threads = [threading.Thread(target=increment) for _ in range(10)]
for t in threads:
t.start()
for t in threads:
t.join()
print(counter) # 輸出 10000000
正確示例
import threading
counter = 0 # 共享資源
lock = threading.Lock() # 創(chuàng)建一個共享的鎖
def increment():
global counter
for _ in range(1000000):
with lock: # 獲取線程鎖
counter += 1
threads = [threading.Thread(target=increment) for _ in range(10)]
for t in threads:
t.start()
for t in threads:
t.join()
print(counter) # 輸出應(yīng)該是10000000
.RLock()可重入鎖，是一種特殊的線程鎖，允許同一線程多次獲得鎖。
import threading
# 創(chuàng)建一個RLock對象
lock = threading.RLock()
def recursive_function(level):
with lock:
if level > 0:
print('Entering level', level)
recursive_function(level - 1)
print('Exiting level', level)
else:
print('Base case')
# 在主線程中運行遞歸函數(shù)
recursive_function(5)
在這個例子中， 是一個遞歸函數(shù)，它會在每個遞歸級別上獲取一次鎖。由于我們使用的是 .RLock，同一線程可以多次獲取鎖，所以這個代碼能夠正常運行。
但是如果我們使用 .Lock 替代 .RLock，那么在第二次嘗試獲取鎖時，線程將被阻塞，因為 .Lock 不允許同一線程多次獲取鎖。這會導(dǎo)致死鎖，程序?qū)o法繼續(xù)運行。
.RLock（ Lock）在Python中是一種可重入鎖，也就是說，它允許同一線程在沒有釋放其所有權(quán)的情況下多次獲取同一個鎖。這在某些情況下是非常有用的，例如在遞歸函數(shù)或者嵌套調(diào)用中。
以下是一些具體的應(yīng)用場景：
遞歸函數(shù)：在遞歸函數(shù)中，同一個線程可能需要多次獲取同一個鎖。如果使用普通的 .Lock，那么在第二次嘗試獲取鎖的時候，線程將會阻塞，因為普通的鎖不允許同一線程多次獲取。而 .RLock 則允許這種行為。復(fù)雜的同步問題：在某些復(fù)雜的同步問題中，你可能需要在同一線程中的多個函數(shù)或者多個不同的代碼塊中獲取同一個鎖。如果使用普通的 .Lock，那么你需要確保在每次獲取鎖之前都已經(jīng)釋放了鎖，這在某些情況下可能會很復(fù)雜。而 .RLock 則可以簡化這種情況的處理。實現(xiàn)高級同步原語：你可以使用 .RLock 來實現(xiàn)一些更高級的同步原語，例如讀寫鎖（）。在這種情況下，讀鎖可以被同一線程多次獲取，而寫鎖只能被同一線程獲取一次。你可以使用 .RLock 來實現(xiàn)讀鎖的行為。
需要注意的是，雖然 .RLock 在某些情況下非常有用，但是在大多數(shù)情況下，你仍然應(yīng)該使用更簡單的 .Lock。因為過度使用 .RLock 可能會使你的代碼更復(fù)雜，更難以理解和維護。而且，不正確的使用 .RLock 可能會導(dǎo)致死鎖。
.()：信號量，用于限制同時訪問某一資源的線程數(shù)量。
模擬一個有限資源池（例如數(shù)據(jù)庫連接池），限制同時訪問資源的線程數(shù)量。
import threading
import time
# 定義一個有限資源池
RESOURCE_POOL_SIZE = 3
semaphore = threading.Semaphore(RESOURCE_POOL_SIZE)
def access_resource(thread_id):
print(f"Thread {thread_id} is requesting access to the resource pool.")
with semaphore:
print(f"Thread {thread_id} has acquired access to the resource pool.")
time.sleep(1) # 模擬資源使用
print(f"Thread {thread_id} has released access to the resource pool.")
# 創(chuàng)建10個線程
threads = [threading.Thread(target=access_resource, args=(i,)) for i in range(10)]
for t in threads:
t.start()
for t in threads:
t.join()
在這個例子中，我們有一個有限的資源池，其大小由 定義。我們使用一個 . 對象，將其初始值設(shè)為資源池的大小，以限制同時訪問資源池的線程數(shù)量。
我們創(chuàng)建了10個線程，每個線程都嘗試訪問資源池。由于我們使用了信號量，一次只能有 個線程同時訪問資源池。其他線程將等待，直到有線程釋放資源。這樣，我們可以限制同時訪問資源的線程數(shù)量，防止資源競爭或過載。
.：有界信號量
import threading
# 創(chuàng)建一個有界信號量，初始值為2
semaphore = threading.BoundedSemaphore(2)
def access_resource(thread_id):
print(f"Thread {thread_id} is requesting access to the resource.")
with semaphore:
print(f"Thread {thread_id} has acquired access to the resource.")
# 模擬資源使用
# 創(chuàng)建3個線程
threads = [threading.Thread(target=access_resource, args=(i,)) for i in range(3)]
for t in threads:
t.start()
for t in threads:
t.join()
# 嘗試釋放未獲取的信號量，將引發(fā) ValueError
try:
semaphore.release()
except ValueError as e:
print("Caught exception:", e)
在這個代碼段中，.release() 嘗試釋放（即增加）信號量的計數(shù)。在Python中，信號量是一個用來限制線程并發(fā)數(shù)量的同步原語，它內(nèi)部有一個計數(shù)器。當(dāng)一個線程調(diào)用 acquire() 方法時，信號量的計數(shù)器減一；當(dāng)一個線程調(diào)用 release() 方法時，信號量的計數(shù)器加一。
. 與 . 的行為基本相同，但有一點不同：如果在調(diào)用 release() 后，信號量的計數(shù)器的值大于創(chuàng)建信號量時設(shè)定的初始值，. 將拋出 異常。這種行為有助于檢測程序中的一些錯誤，例如錯誤地多次釋放了信號量。
所以在這個示例中，try/except 塊是為了捕獲并處理可能由 .release() 拋出的 異常。如果在調(diào)用 release() 后，信號量的計數(shù)器的值大于創(chuàng)建信號量時設(shè)定的初始值，那么將會捕獲到 ，并打印出 “Caught :” 及其錯誤信息。
.：條件變量，允許一個或多個線程等待某個條件滿足，然后喚醒。
import threading
import time
# 創(chuàng)建一個條件變量
condition = threading.Condition()
# 創(chuàng)建一個共享資源
resource = []
def producer():
for i in range(5):
time.sleep(1) # 模擬生產(chǎn)過程
with condition:
resource.append(i) # 向資源中添加數(shù)據(jù)
condition.notify() # 喚醒一個等待的線程
def consumer():
while True:
with condition:
while not resource: # 如果資源為空，則等待
condition.wait()
item = resource.pop(0) # 從資源中獲取數(shù)據(jù)
print(f"Consumer consumed: {item}")
if item == 4: # 如果消費了所有的資源，就退出循環(huán)
break
# 創(chuàng)建一個生產(chǎn)者線程和一個消費者線程
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)
producer_thread.start()
consumer_thread.start()
producer_thread.join()
consumer_thread.join()
. 對象常常與一個鎖一起使用，允許一個或多個線程等待直到滿足某個特定的條件，然后喚醒。這在某些情況下很有用，比如當(dāng)你需要一個或多個線程等待直到其他線程完成特定任務(wù)或者改變了某個狀態(tài)。
.Barrier：柵欄對象，允許一定數(shù)量的線程同步，直到所有線程都到達柵欄位置，才會全部釋放
import threading
import time
# 設(shè)定柵欄，允許3個線程進行同步
barrier = threading.Barrier(3)
def worker(thread_id):
print(f"Thread {thread_id} is starting.")
time.sleep(thread_id) # 模擬線程執(zhí)行過程中的延時
print(f"Thread {thread_id} is waiting at the barrier.")
barrier.wait() # 等待所有線程到達柵欄
print(f"Thread {thread_id} is released from the barrier.")
# 創(chuàng)建3個線程
threads = [threading.Thread(target=worker, args=(i,)) for i in range(3)]
for t in threads:
t.start()
for t in threads:
t.join()
在這個例子中，我們創(chuàng)建了一個柵欄對象，允許3個線程進行同步。然后我們創(chuàng)建了3個線程，每個線程都會執(zhí)行 worker 函數(shù)。在 worker 函數(shù)中，線程首先打印一個開始信息，然后等待一段時間（這里是線程ID，可以模擬線程執(zhí)行過程中的延時），接著打印一個等待信息，然后調(diào)用 barrier.wait() 等待柵欄。
當(dāng)所有3個線程都調(diào)用了 barrier.wait()，柵欄將釋放所有等待的線程。這時，線程將繼續(xù)執(zhí)行并打印它們已經(jīng)從柵欄中釋放的信息。這個示例演示了如何使用 .Barrier 對象來同步一組線程，確保它們在某個點上相互等待。