Python - 線程死鎖

你好，有抱負的程式設計師！今天，我們將深入Python線程的迷人世界，並探索一個常見的陷阱：死鎖。如果你是编程新手，不必擔心；我會一步步引導你理解這個概念，就像我多年教學中為無數學生所做的那樣。所以，拿起一杯你最喜歡的飲料，讓我們一起踏上這個激動人心的旅程吧！

Python - Thread Deadlock

什麼是死鎖？

在我們深入Python線程的細節之前，先來了解什麼是死鎖。想象一下，你和你的一個朋友在一個環形走廊裡，你們都拿著一個大箱子，要通過對方，其中一人需要放下箱子。但這裡有個問題：你們都決定不放下箱子，除非對方先放。現在你卡住了！這基本上就是程序設計中的死鎖——當兩個或多個線程彼此等待釋放資源，而沒有任何一個能夠繼續進行。

如何在Python線程中避免死鎖

現在我們已經了解了死鎖是什麼，接下來看看如何在Python中避免它們。我們可以採用幾種策略：

1. 鎖定排序

避免死鎖的最簡單方法之一是始終以一致的順序獲取鎖定。我們來看一個例子：

import threading

lock1 = threading.Lock()
lock2 = threading.Lock()

def worker1():
with lock1:
print("Worker1獲得了lock1")
with lock2:
print("Worker1獲得了lock2")
# 進行一些工作

def worker2():
with lock1:
print("Worker2獲得了lock1")
with lock2:
print("Worker2獲得了lock2")
# 進行一些工作

t1 = threading.Thread(target=worker1)
t2 = threading.Thread(target=worker2)

t1.start()
t2.start()
t1.join()
t2.join()

在這個例子中，worker1和worker2都先獲取lock1，然後獲取lock2。這種一致的順序可以防止死鎖。

2. 超時機制

另一種策略是在獲取鎖時使用超時。如果線程在一定的時間內無法獲取鎖，它就放棄並稍後再試。以下是如何實現這一點：

import threading
import time

lock = threading.Lock()

def worker(id):
while True:
if lock.acquire(timeout=1):
try:
print(f"Worker {id} 獲得了鎖")
time.sleep(2)  # 模擬一些工作
finally:
lock.release()
print(f"Worker {id} 釋放了鎖")
else:
print(f"Worker {id} 無法獲得鎖，正在重試...")
time.sleep(0.5)  # 在重試之前等待

t1 = threading.Thread(target=worker, args=(1,))
t2 = threading.Thread(target=worker, args=(2,))

t1.start()
t2.start()

在這個例子中，如果工作緒在1秒內無法獲取鎖，它會打印一條消息並在短時間延遲後重試。

使用鎖對象的鎖定機制

Python中的Lock對像是線程之間同步的基本工具。它就像一把只有一個線程能夠一次持有的一把鑰匙。我們來看看如何使用它：

import threading
import time

counter = 0
lock = threading.Lock()

def increment():
global counter
with lock:
current = counter
time.sleep(0.1)  # 模擬一些工作
counter = current + 1

threads = []
for i in range(10):
t = threading.Thread(target=increment)
threads.append(t)
t.start()

for t in threads:
t.join()

print(f"最終計數器值：{counter}")

在這個例子中，我們使用鎖來確保一次只有一個線程可以修改計數器。with語句自動獲取和釋放鎖。

用於同步的Semaphore對象

Semaphore就像俱樂部的門衛，一次只允許一定數量的人進入。當你想限制對資源的訪問時，這很有用。以下是如何使用它：

import threading
import time

semaphore = threading.Semaphore(2)  # 同時允許2個線程

def worker(id):
with semaphore:
print(f"Worker {id} 正在工作")
time.sleep(2)  # 模擬一些工作
print(f"Worker {id} 完成了")

threads = []
for i in range(5):
t = threading.Thread(target=worker, args=(i,))
threads.append(t)
t.start()

for t in threads:
t.join()

在這個例子中，即使我們創建了5個線程，由於Semaphore，只有2個可以同時"工作"。

結論

恭喜你！你剛剛走出了Python線程世界的第一步，並學會了如何避免可怕的死鎖。請記住，就像學習騎自行車一樣，掌握線程需要練習。如果一開始沒有立即領悟，不要氣餒——繼續編程，繼續實驗，你很快就會像專家一樣進行線程處理！

以下是我們討論過的方法的摘要：

方法	描述
鎖定排序	以一貫的順序獲取鎖
超時機制	獲取鎖時使用超時
鎖對象	基本同步工具
Semaphore	限制對資源的訪問

將這些工具放在你的編程工具箱中，你將能夠很好地處理並發編程挑戰。開心編程，未來的Python大師们！

Credits: Image by storyset