【乾貨】趣味詳解 3 種 Python 執行緒鎖

執行緒安全

• 執行緒1對num進行一千萬次+1的操作
• 執行緒2對num進行一千萬次-1的操作
  

import threading

num = 0


def add():
    global num
    for i in range(10_000_000):
        num += 1


def sub():
    global num
    for i in range(10_000_000):
        num -= 1


if __name__ == "__main__":
    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

# 結果三次採集
# num result : 669214
# num result : -1849179
# num result : -525674

鎖的作用

• 同步鎖：lock（一次只能放行一個）
• 遞迴鎖：rlock（一次只能放行一個）
• 條件鎖：condi on（一次可以放行任意個）
• 事件鎖：event（一次全部放行）
• 訊號量鎖：semaphore（一次可以放行特定個）
  

1、Lock() 同步鎖 基本介紹

• 同步鎖
• 互斥鎖
  

• 互斥指的是某一資源同一時刻僅能有一個訪問者對其進行訪問，具有唯一性和排他性，但是互斥無法限制訪問者對資源的訪問順序，即訪問是無序的
• 同步是指在互斥的基礎上（大多數情況），透過其他機制實現訪問者對資源的有序訪問
• 同步其實已經實現了互斥，是互斥的一種更為複雜的實現，因為它在互斥的基礎上實現了有序訪問的特點
  

方法描述
threading.Lock()返回一個同步鎖物件
lockObject.acquire(blocking=True, timeout=1)上鎖，當一個執行緒在執行被上鎖程式碼塊時，將不允許切換到其他執行緒執行，預設鎖失效時間為1秒
lockObject.release()解鎖，當一個執行緒在執行未被上鎖程式碼塊時，將允許系統根據策略自行切換到其他執行緒中執行
lockObject.locaked()判斷該鎖物件是否處於上鎖狀態，返回一個布林值 使用方式

import threading

num = 0


def add():
    lock.acquire()
    global num
    for i in range(10_000_000):
        num += 1
    lock.release()


def sub():
    lock.acquire()
    global num
    for i in range(10_000_000):
        num -= 1
    lock.release()

if __name__ == "__main__":
    lock = threading.Lock()

    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

# 結果三次採集
# num result : 0
# num result : 0
# num result : 0

死鎖現象

import threading

num = 0


def add():
    lock.acquire()  # 上鎖
    lock.acquire()  # 死鎖
    # 不執行
    global num
    for i in range(10_000_000):
        num += 1
    lock.release()
    lock.release()


def sub():
    lock.acquire()  # 上鎖
    lock.acquire()  # 死鎖
    # 不執行
    global num
    for i in range(10_000_000):
        num -= 1
    lock.release()
    lock.release()


if __name__ == "__main__":
    lock = threading.Lock()

    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)
with語句

import threading

num = 0


def add():
    with lock:
        # 自動加鎖
        global num
        for i in range(10_000_000):
            num += 1
        # 自動解鎖


def sub():
    with lock:
        # 自動加鎖
        global num
        for i in range(10_000_000):
            num -= 1
        # 自動解鎖


if __name__ == "__main__":
    lock = threading.Lock()

    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)
   
# 結果三次採集
# num result : 0
# num result : 0
# num result : 0
2、RLock() 遞迴鎖 基本介紹

方法描述
threading.RLock()返回一個遞迴鎖物件
lockObject.acquire(blocking=True, timeout=1)上鎖，當一個執行緒在執行被上鎖程式碼塊時，將不允許切換到其他執行緒執行，預設鎖失效時間為1秒
lockObject.release()解鎖，當一個執行緒在執行未被上鎖程式碼塊時，將允許系統根據策略自行切換到其他執行緒中執行
lockObject.locaked()判斷該鎖物件是否處於上鎖狀態，返回一個布林值 使用方式

import threading

num = 0


def add():
    lock.acquire()
    lock.acquire()
    global num
    for i in range(10_000_000):
        num += 1
    lock.release()
    lock.release()


def sub():
    lock.acquire()
    lock.acquire()
    global num
    for i in range(10_000_000):
        num -= 1
    lock.release()
    lock.release()


if __name__ == "__main__":
    lock = threading.RLock()

    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

# 結果三次採集
# num result : 0
# num result : 0
# num result : 0
with語句

import threading

num = 0


def add():
    with lock:
        # 自動加鎖
        global num
        for i in range(10_000_000):
            num += 1
        # 自動解鎖


def sub():
    with lock:
        # 自動加鎖
        global num
        for i in range(10_000_000):
            num -= 1
        # 自動解鎖


if __name__ == "__main__":
    lock = threading.RLock()

    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

# 結果三次採集
# num result : 0
# num result : 0
# num result : 0
3、Condition() 條件鎖 基本介紹

方法描述
threading.Condition()返回一個條件鎖物件
lockObject.acquire(blocking=True, timeout=1)上鎖，當一個執行緒在執行被上鎖程式碼塊時，將不允許切換到其他執行緒執行，預設鎖失效時間為1秒
lockObject.release()解鎖，當一個執行緒在執行未被上鎖程式碼塊時，將允許系統根據策略自行切換到其他執行緒中執行
lockObject.wait(timeout=None)將當前執行緒設定為“等待”狀態，只有該執行緒接到“通知”或者超時時間到期之後才會繼續執行，在“等待”狀態下的執行緒將允許系統根據策略自行切換到其他執行緒中執行
lockObject.wait_for(predicate, timeout=None)將當前執行緒設定為“等待”狀態，只有該執行緒的predicate返回一個True或者超時時間到期之後才會繼續執行，在“等待”狀態下的執行緒將允許系統根據策略自行切換到其他執行緒中執行。注意：predicate引數應當傳入一個可呼叫物件，且返回結果為bool型別
lockObject.notify(n=1)通知一個當前狀態為“等待”的執行緒繼續執行，也可以透過引數n通知多個
lockObject.notify_all()通知所有當前狀態為“等待”的執行緒繼續執行 使用方式

import threading

currentRunThreadNumber = 0
maxSubThreadNumber = 10


def task():
    global currentRunThreadNumber
    thName = threading.currentThread().name

    condLock.acquire()  # 上鎖
    print("start and wait run thread : %s" % thName)

    condLock.wait()  # 暫停執行緒執行、等待**
    currentRunThreadNumber += 1
    print("carry on run thread : %s" % thName)

    condLock.release()  # 解鎖


if __name__ == "__main__":
    condLock = threading.Condition()

    for i in range(maxSubThreadNumber):
        subThreadIns = threading.Thread(target=task)
        subThreadIns.start()

    while currentRunThreadNumber < maxSubThreadNumber:
        notifyNumber = int(
            input("Please enter the number of threads that need to be notified to run："))

        condLock.acquire()
        condLock.notify(notifyNumber)  # 放行
        condLock.release()

    print("main thread run end")
   
# 先啟動10個子執行緒，然後這些子執行緒會全部變為等待狀態
# start and wait run thread : Thread-1
# start and wait run thread : Thread-2
# start and wait run thread : Thread-3
# start and wait run thread : Thread-4
# start and wait run thread : Thread-5
# start and wait run thread : Thread-6
# start and wait run thread : Thread-7
# start and wait run thread : Thread-8
# start and wait run thread : Thread-9
# start and wait run thread : Thread-10

# 批次傳送通知，放行特定數量的子執行緒繼續執行
# Please enter the number of threads that need to be notified to run：5  # 放行5個
# carry on run thread : Thread-4
# carry on run thread : Thread-3
# carry on run thread : Thread-1
# carry on run thread : Thread-2
# carry on run thread : Thread-5

# Please enter the number of threads that need to be notified to run：5  # 放行5個
# carry on run thread : Thread-8
# carry on run thread : Thread-10
# carry on run thread : Thread-6
# carry on run thread : Thread-9
# carry on run thread : Thread-7

# Please enter the number of threads that need to be notified to run：1
# main thread run end
with語句

import threading

currentRunThreadNumber = 0
maxSubThreadNumber = 10


def task():
    global currentRunThreadNumber
    thName = threading.currentThread().name

    with condLock:
        print("start and wait run thread : %s" % thName)
        condLock.wait()  # 暫停執行緒執行、等待**
        currentRunThreadNumber += 1
        print("carry on run thread : %s" % thName)


if __name__ == "__main__":
    condLock = threading.Condition()

    for i in range(maxSubThreadNumber):
        subThreadIns = threading.Thread(target=task)
        subThreadIns.start()

    while currentRunThreadNumber < maxSubThreadNumber:
        notifyNumber = int(
            input("Please enter the number of threads that need to be notified to run："))

        with condLock:
            condLock.notify(notifyNumber)  # 放行

    print("main thread run end")