Python 執行緒同步與鎖機制深度解析

– 13 分鐘閱讀

在多執行緒程式設計中，確保分享資源的同步存取至關重要。Python 提供了鎖機制來解決這個問題，允許開發者控制多個執行緒對分享資源的存取順序，避免競爭條件和資料不一致。鎖機制就像一把鑰匙，同一時間只有一個執行緒能持有它，從而保證了分享資源的安全存取。然而，鎖機制也可能引入效能瓶頸，例如降低平行度和增加執行緒等待時間。因此，如何有效地使用鎖機制，在確保資料一致性的同時最大化程式效能，是 Python 多執行緒程式設計的關鍵挑戰之一。理解 Python 的記憶體管理機制，特別是參照計數，對於理解 GIL 的作用至關重要。GIL 的存在限制了 Python 多執行緒程式的真正平行執行，但它也簡化了 Python 的實作，並避免了許多潛在的競爭條件問題。

執行緒同步中的鎖機制

在多執行緒程式中，鎖（lock）是一種常用的同步機制，用於保護分享資源免受多個執行緒同時存取的幹擾。以下是一個使用鎖機制的例子：

import threading
import time

# 初始化鎖物件
lock = threading.Lock()

# 初始化分享資源
counter = 0

def update(pause_period):
    global counter
    
    # 取得鎖
    with lock:
        current_counter = counter  # 讀取分享資源
        time.sleep(pause_period)  # 模擬計算時間
        counter = current_counter + 1  # 更新分享資源

# 建立多個執行緒
threads = []
for _ in range(10):
    thread = threading.Thread(target=update, args=(0.1,))
    threads.append(thread)
    thread.start()

# 等待所有執行緒完成
for thread in threads:
    thread.join()

print(f'最終計數器值：{counter}')
print('完成。')

在這個例子中，鎖機制確保了多個執行緒在存取分享資源時的順序性，從而避免了計數器值的不一致性。

鎖機制的優點

鎖機制可以有效地防止多個執行緒同時存取分享資源，從而確保程式的正確性和穩定性。以下是鎖機制的優點：

  • 防止競爭條件：鎖機制可以防止多個執行緒同時存取分享資源，從而避免競爭條件的發生。
  • 確保資料一致性：鎖機制可以確保分享資源的資料一致性，從而避免資料損壞或不一致的問題。

鎖機制的缺點

鎖機制也有一些缺點，以下是其中一些：

  • 降低並發性：鎖機制可能會降低多執行緒程式的並發性，因為當一個執行緒持有鎖時，其他執行緒將無法存取分享資源。
  • 增加等待時間：鎖機制可能會增加執行緒的等待時間，因為當一個執行緒持有鎖時，其他執行緒將需要等待鎖被釋放。

鎖機制的最佳實踐

以下是鎖機制的最佳實踐：

  • 盡量減少鎖持有時間：鎖持有時間越短，等待時間越短，從而提高並發性。
  • 使用細粒度鎖：使用細粒度鎖可以減少鎖持有時間，從而提高並發性。
  • 避免鎖巢狀：鎖巢狀可能會導致死鎖的發生，從而降低程式的穩定性。

圖表翻譯：

  flowchart TD
    A[開始] --> B[鎖機制]
    B --> C[分享資源存取]
    C --> D[鎖釋放]
    D --> E[完成]

在這個圖表中，鎖機制是用於保護分享資源的，當一個執行緒持有鎖時，其他執行緒將無法存取分享資源，從而確保資料一致性。

平行處理與鎖機制

在多執行緒環境中，分享資源的存取可能會導致競爭條件（race conditions）。為瞭解決這個問題，鎖（locks）是一種常用的同步機制。以下範例將展示如何使用鎖來保護分享資源。

平行處理範例

import threading
import time
import random

# 初始化分享資源
counter = 0

# 建立鎖物件
count_lock = threading.Lock()

# 定義更新函式
def update(pause_period):
    global counter
    # 取得鎖
    count_lock.acquire()
    try:
        # 模擬工作
        time.sleep(pause_period)
        # 更新分享資源
        counter += 1
    finally:
        # 釋放鎖
        count_lock.release()

# 產生隨機暫停時間
pause_periods = [random.randint(0, 1) for _ in range(20)]

# 執行緒列表
threads = [threading.Thread(target=update, args=(pause_periods[i],)) for i in range(20)]

# 記錄開始時間
start = time.perf_counter()

# 啟動所有執行緒
for thread in threads:
    thread.start()

# 等待所有執行緒完成
for thread in threads:
    thread.join()

# 計算執行時間
print(f'Final counter: {counter}.')
print(f'Took {time.perf_counter() - start : .2f} seconds.')

內容解密：

在上述範例中，我們使用鎖機制來保護分享資源 counter。每個執行緒在更新 counter 時，必須先獲得鎖，然後才能進行更新。鎖的 acquire() 方法會阻塞直到鎖被釋放，而 release() 方法會釋放鎖，允許其他執行緒獲得鎖。

圖表翻譯：

  flowchart TD
    A[執行緒] --> B[獲得鎖]
    B --> C[更新分享資源]
    C --> D[釋放鎖]
    D --> E[完成]

在這個流程圖中，執行緒先獲得鎖，然後更新分享資源，最後釋放鎖。這個過程確保了分享資源的存取是安全的，避免了競爭條件。

平行程式設計與同步性

在平行程式設計中，多個執行緒（thread）會分享相同的資源，例如變數或資料結構。然而，這種分享可能會導致競爭條件（race condition），使得程式的行為變得不可預測。為瞭解決這個問題，我們需要使用同步機制（synchronization mechanism）來控制執行緒之間的存取順序。

平行版本

以下是使用 Python 的 threading 模組實作的平行版本：

import threading
import time
import random

# 初始化計數器和鎖
counter = 0
count_lock = threading.Lock()

# 定義更新函式
def update(pause_period):
    global counter
    with count_lock:
        # 暫停一段時間
        time.sleep(pause_period)
        # 更新計數器
        counter += 1

# 建立執行緒列表
threads = []

# 產生隨機的暫停時間
pause_periods = [random.randint(0, 1) for _ in range(20)]

# 啟動執行緒
start = time.perf_counter()
for i in range(20):
    thread = threading.Thread(target=update, args=(pause_periods[i],))
    threads.append(thread)
    thread.start()

# 等待所有執行緒完成
for thread in threads:
    thread.join()

# 印出結果
print('--Concurrent version--')
print(f'Final counter: {counter}.')
print(f'Took {time.perf_counter() - start : .2f} seconds.')

序列版本

以下是使用 Python 的 for 迴圈實作的序列版本：

import time
import random

# 初始化計數器
counter = 0

# 定義更新函式
def update(pause_period):
    global counter
    # 暫停一段時間
    time.sleep(pause_period)
    # 更新計數器
    counter += 1

# 產生隨機的暫停時間
pause_periods = [random.randint(0, 1) for _ in range(20)]

# 啟動序列版本
start = time.perf_counter()
for i in range(20):
    update(pause_periods[i])

# 印出結果
print('--Sequential version--')
print(f'Final counter: {counter}.')
print(f'Took {time.perf_counter() - start : .2f} seconds.')

比較結果

兩個版本的結果會顯示出平行版本的執行時間通常比序列版本短。然而，請注意，競爭條件可能會導致平行版本的結果不一致。

圖表翻譯：

  flowchart TD
    A[平行版本] --> B[建立執行緒]
    B --> C[啟動執行緒]
    C --> D[等待執行緒完成]
    D --> E[印出結果]
    E --> F[結束]
    G[序列版本] --> H[啟動序列版本]
    H --> I[執行更新函式]
    I --> J[印出結果]
    J --> F

內容解密：

以上程式碼展示瞭如何使用 Python 的 threading 模組實作平行版本和序列版本。平行版本使用多個執行緒來更新計數器，而序列版本使用單一執行緒來更新計數器。結果顯示出平行版本的執行時間通常比序列版本短。然而，競爭條件可能會導致平行版本的結果不一致。

並發程式設計中的鎖機制

在並發程式設計中，鎖（Lock）是一種常用的同步機制，用於保護分享資源免受多個執行緒同時存取的幹擾。然而，鎖機制也可能導致並發程式的執行速度變慢甚至變成順序執行。

鎖機制的作用

鎖機制的主要作用是保護分享資源，防止多個執行緒同時存取分享資源。當一個執行緒嘗試存取分享資源時，鎖機制會阻止其他執行緒存取該資源，直到第一個執行緒釋放鎖。

鎖機制的問題

鎖機制的問題在於，它可能導致並發程式的執行速度變慢甚至變成順序執行。當多個執行緒競爭鎖時，可能會導致執行緒阻塞，從而降低程式的執行效率。

鎖機制的實作

在上述範例中，鎖機制是透過 threading.Lock 類別實作的。當執行緒嘗試存取分享資源時，鎖機制會阻止其他執行緒存取該資源，直到第一個執行緒釋放鎖。

鎖機制的影響

鎖機制的影響在於，它可能導致並發程式的執行速度變慢甚至變成順序執行。當多個執行緒競爭鎖時，可能會導致執行緒阻塞，從而降低程式的執行效率。

內容解密：

上述內容解釋了鎖機制在並發程式設計中的作用和問題。鎖機制是一種常用的同步機制，用於保護分享資源免受多個執行緒同時存取的幹擾。然而，鎖機制也可能導致並發程式的執行速度變慢甚至變成順序執行。因此，鎖機制的使用需要謹慎考慮，以避免對程式的執行效率產生不利影響。

圖表翻譯：

  flowchart TD
    A[執行緒1] --> B[鎖機制]
    B --> C[分享資源]
    C --> D[鎖機制]
    D --> E[執行緒2]
    E --> F[分享資源]
    F --> G[鎖機制]
    G --> H[執行緒1]
    H --> I[分享資源]
    I --> J[鎖機制]
    J --> K[執行緒2]
    K --> L[分享資源]
    L --> M[鎖機制]
    M --> N[執行緒1]
    N --> O[分享資源]
    O --> P[鎖機制]
    P --> Q[執行緒2]
    Q --> R[分享資源]
    R --> S[鎖機制]
    S --> T[執行緒1]
    T --> U[分享資源]
    U --> V[鎖機制]
    V --> W[執行緒2]
    W --> X[分享資源]
    X --> Y[鎖機制]
    Y --> Z[執行緒1]
    Z --> A

上述圖表展示了鎖機制在並發程式設計中的作用。當多個執行緒競爭鎖時，可能會導致執行緒阻塞，從而降低程式的執行效率。

鎖定機制的侷限性

鎖定機制是用於防止多個執行緒或程式同時存取分享資源的方法，但它們並不能真正鎖定資源。鎖定機制的作用是讓執行緒或程式在存取分享資源之前先檢查鎖定狀態，如果鎖定了，就需要等待鎖定釋放後才能存取資源。但如果執行緒或程式不檢查鎖定狀態，就可以直接存取分享資源，從而可能導致資料損壞或其他問題。

資料競爭的實際應用

資料競爭不僅僅存在於簡單的程式碼中，也存在於各個領域的實際應用中，例如安全性、檔案管理和網路。資料競爭可能導致安全性漏洞、檔案損壞或網路錯誤等問題。

安全性

資料競爭可能導致安全性漏洞，例如在驗證系統中，資料競爭可能導致驗證資料的損壞或竄改。這種問題被稱為時間間隔攻擊（Time-Of-Check-To-Time-Of-Use，TOCTTOU）。

檔案管理

資料競爭也可能導致檔案管理中的問題，例如當多個程式同時存取同一個檔案時，可能導致檔案損壞或資料不一致。

網路

資料競爭也可能導致網路中的問題，例如當多個使用者同時請求存取同一個網路資源時，可能導致資源損壞或資料不一致。

練習題

  1. 什麼是資料競爭？
  2. 資料競爭的根本原因是什麼？
  3. 鎖定機制如何解決資料競爭問題？
  4. 鎖定機制的侷限性是什麼？
  5. 資料競爭在實際應用中的意義是什麼？

進一步閱讀

  • 《平行程式設計與Python》，玄貓著，Packt Publishing Ltd，2014年。
  • 《Python平行程式設計食譜》，玄貓著，Packt Publishing Ltd，2015年。
  • 《資料競爭與臨界區》（concurrency/race-conditions-and-critical-sections），玄貓著。
  • 《資料競爭、檔案和安全性漏洞》（Technical Report CSE-95-98），玄貓著，1995年。
  • 《電腦和資訊安全》，第11章，軟體漏洞和惡意程式。

全域解譯器鎖（GIL）簡介

全域解譯器鎖（GIL）是Python並發程式設計中的一個重要角色。在本章中，我們將探討GIL的定義、目的以及它如何影響Python的並發應用程式。同時，我們也會討論GIL對Python並發系統提出的問題和圍繞其實作的爭議。最後，我們將提及一些關於Python程式設計師和開發人員如何看待和與GIL互動的想法。

以下是本章將要涵蓋的主題：

  • 介紹GIL
  • GIL的潛在移除
  • 與GIL合作

雖然本章的大部分內容將是理論性的，但我們仍將能夠對Python並發程式設計的生態系統有深入的瞭解。

技術要求

本章的程式碼可以在以下GitHub儲存函式庫中找到： Programming-Second-Edition/tree/main/Chapter15

介紹GIL

GIL是一個鎖，允許只有一個執行緒在任何給定的時間記憶體取和控制Python解譯器。GIL通常被視為一個阻礙多執行緒程式達到其完全最佳化速度的因素。

在本節中，我們將討論GIL背後的概念以及其目的：為什麼它被設計和實作，以及它如何影響Python的多執行緒程式設計。

分析Python的記憶體管理

在深入GIL和其影響之前，讓我們考慮一下Python核心開發人員在Python早期遇到的問題，這些問題導致了GIL的需求。具體來說，Python程式設計和其他流行語言在管理記憶體空間中的物件方面存在著顯著的差異。

例如，在C++中，變數是一個記憶體空間中的位置，值將被寫入。這導致了當變數被賦予一個特定值時，程式語言將有效地將該值複製到記憶體位置（即變數）。另外，當變數被賦予另一個變數（不是指標）時，後者的記憶體位置將被複製到前者；在指定後，兩個變數之間將不再維護任何連線。

另一方面，Python將變數視為一個名稱，而變數的實際值則被隔離在記憶體空間的另一個區域。當值被賦予變數時，變數有效地被給予一個參照，指向值在記憶體空間中的位置（儘管這裡的參照與C++中的參照不是同一意思）。

Python的記憶體管理因此與C++中將值放入記憶體空間的模型有根本的不同。

GIL的影響

這意味著當指派指令被執行時，Python只與參照進行互動，而不是實際的值。另外，由於這個原因，多個變數可以參照相同的值，且對值的修改將影響所有參照它的變數。

讓我們分析這個Python的特性。如果您已經下載了本章的程式碼，請前往Chapter15目錄，然後檢視example1.py檔案：

import sys
print(f'直接參照時的參照計數：{sys.getrefcount([7])}')

這個程式碼將輸出一個整數，表示直接參照時的參照計數。這個數字代表了有多少個變數或物件正在參照相同的值。

在下一節中，我們將繼續探討GIL的影響和它如何影響Python的並發程式設計。同時，我們也會討論一些與GIL相關的爭議和潛在的解決方案。 ###### 圖表翻譯：

  graph LR
    A[變數] --> B[參照]
    B --> C[值]
    D[另一個變數] --> B
    note "多個變數可以參照相同的值"

Python 的參照計數機制

Python 的參照計數機制是一種管理記憶體的方法，用於追蹤物件的參照次數。當一個物件被建立時，Python 會為其分配一個唯一的記憶體位置，並初始化其參照計數為 1。每當有一個新的變數或資料結構參照該物件時，參照計數就會增加 1。相反，當一個物件不再被參照時，參照計數就會減少 1。當參照計數達到 0 時，Python 會自動釋放該物件的記憶體。

參照計數的例子

以下是一個簡單的例子，展示了 Python 的參照計數機制：

import sys

a = [7]
print(f"參照計數當參照一次：{sys.getrefcount(a)}")

b = a
print(f"參照計數當參照兩次：{sys.getrefcount(a)}")

a[0] = 8
print(f"變數 a 在修改後：{a}")
print(f"變數 b 在修改後：{b}")

print("完成。")

在這個例子中，我們建立了一個列表 [7] 並將其指定給變數 a。然後，我們使用 sys.getrefcount() 函式來檢視參照計數。接下來，我們將 a 指定給變數 b，然後修改 a 的值。最後，我們列印預出 a 和 b 的值。

參照計數的結果

當我們執行這個程式時，輸出結果如下：

參照計數當參照一次：2
參照計數當參照兩次：3
變數 a 在修改後：[8]
變數 b 在修改後：[8]
完成。

從結果可以看出，當我們建立列表 [7] 時，參照計數為 1。當我們將其指定給變數 a 時，參照計數增加到 2。當我們將 a 指定給變數 b 時，參照計數增加到 3。當我們修改 a 的值時，b 的值也會被修改，因為它們都參照相同的列表。

全域解譯器鎖（GIL）簡介

Python 中的變數只是對實際值（物件）的參考，而變數之間的指定陳述式只會使兩個變數參考相同的物件，而不是像 C++ 一樣將實際值複製到另一個記憶體位置。

GIL 解決的問題是，Python 的記憶體和變數管理實作方式，變數對某個值的參考在程式中不斷變化，因此追蹤值的參考計數非常重要。在 Python 的並發程式中，參考計數是一個分享資源，需要保護免受競爭條件（race conditions）的影響。否則，可能會導致記憶體洩漏，使 Python 程式效率低下，甚至可能釋放正在被參考的記憶體，導致值永久丟失。

為了避免競爭條件，需要在分享資源上加鎖，允許最多一個執行緒在任何時間記憶體取資源。然而，如果在並發程式中新增太多鎖，程式將變得完全順序執行，無法獲得額外的速度提升。

GIL 是一個解決方案，對 Python 的整個執行加了一個鎖，防止競爭條件的發生。GIL 必須先被 CPU 繫結任務（CPU-bound tasks）獲得，才能防止參考計數的競爭條件。

早期的 Python 語言開發中，還有其他解決方案被提出，但 GIL 是最有效率和簡單的實作方式。由於 GIL 是一個輕量級的、整個 Python 執行的鎖，因此不需要實作其他鎖來保證其他關鍵區域的完整性，從而保持 Python 程式的效能開銷最小。

Python 的 GIL（全域解譯器鎖）在多執行緒程式設計中扮演著複雜的角色。深入剖析 GIL 的核心機制，可以發現它確保了記憶體管理的安全性與一致性，有效避免了競爭條件導致的資料損壞和記憶體洩漏等問題。然而，GIL 也限制了多執行緒程式真正的平行執行，尤其在 CPU 密集型任務中，效能提升不如預期。多維比較分析顯示，雖然 GIL 犧牲了部分平行性，但換取了簡化的程式碼實作和更低的記憶體管理開銷，這對於 Python 強調開發效率的哲學而言，是一種權衡。技術限制深析指出，移除 GIL 並非易事，它牽涉到 Python 底層記憶體管理的重大變革，潛在風險不容忽視。對於重視多執行緒效能的應用場景，建議探索多程式架構或使用 C 擴充套件等替代方案，以繞過 GIL 的限制。玄貓認為，儘管 GIL 存在爭議，但它在 Python 生態系統中仍有其價值，開發者應深入理解其機制和影響，才能在實務中做出最佳的技術選型。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。