Python3中最常用的5種執行緒鎖你會用嗎

雲崖君發表於2021-07-02

前言

本章節將繼續圍繞threading模組講解，基本上是純理論偏多。

對於日常開發者來講很少會使用到本章節的內容，但是對框架作者等是必備知識，同時也是高頻的面試常見問題。

執行緒安全

執行緒安全是多執行緒或多程式程式設計中的一個概念，在擁有共享資料的多條執行緒並行執行的程式中，執行緒安全的程式碼會通過同步機制保證各個執行緒都可以正常且正確的執行，不會出現資料汙染等意外情況。

執行緒安全的問題最主要還是由執行緒切換導致的，比如一個房間（程式）中有10顆糖（資源），除此之外還有3個小人（1個主執行緒、2個子執行緒），當小人A吃了3顆糖後被系統強制進行休息時他認為還剩下7顆糖，而當小人B工作後又吃掉了3顆糖，那麼當小人A重新上崗時會認為糖還剩下7顆，但是實際上只有4顆了。

上述例子中執行緒A和執行緒B的資料不同步，這就是執行緒安全問題，它可能導致非常嚴重的意外情況發生，我們按下面這個示例來進行說明。

下面有一個數值num初始值為0，我們開啟2條執行緒：

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

結果可能會令人咋舌，num最後並不是我們所想象的結果0：

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

上面這就是一個非常好的案例，想要解決這個問題就必須通過鎖來保障執行緒切換的時機。

需要我們值得留意的是，在Python基本資料型別中list、tuple、dict本身就是屬於執行緒安全的，所以如果有多個執行緒對這3種容器做操作時，我們不必考慮執行緒安全問題。

鎖的作用

鎖是Python提供給我們能夠自行操控執行緒切換的一種手段，使用鎖可以讓執行緒的切換變的有序。

一旦執行緒的切換變的有序後，各個執行緒之間對資料的訪問、修改就變的可控，所以若要保證執行緒安全，就必須使用鎖。

threading模組中提供了5種最常見的鎖，下面是按照功能進行劃分：

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

Lock() 同步鎖

基本介紹

Lock鎖的稱呼有很多，如：

同步鎖
互斥鎖

它們是什麼意思呢？如下所示：

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

下面是threading模組與同步鎖提供的相關方法：

方法	描述
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

這樣這個程式碼就完全變成了序列的狀態，對於這種計算密集型I/O業務來說，還不如直接使用序列化單執行緒執行來得快，所以這個例子僅作為一個示例，不能概述鎖真正的用途。

死鎖現象

對於同步鎖來說，一次acquire()必須對應一次release()，不能出現連續重複使用多次acquire()後再重複使用多次release()的操作，這樣會引起死鎖造成程式的阻塞，完全不動了，如下所示：

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語句

由於threading.Lock()物件中實現了__enter__()與__exit__()方法，故我們可以使用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

RLock() 遞迴鎖

基本介紹

遞迴鎖是同步鎖的一個升級版本，在同步鎖的基礎上可以做到連續重複使用多次acquire()後再重複使用多次release()的操作，但是一定要注意加鎖次數和解鎖次數必須一致，否則也將引發死鎖現象。

下面是threading模組與遞迴鎖提供的相關方法：

方法	描述
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語句

由於threading.RLock()物件中實現了__enter__()與__exit__()方法，故我們可以使用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

Condition() 條件鎖

基本介紹

條件鎖是在遞迴鎖的基礎上增加了能夠暫停執行緒執行的功能。並且我們可以使用wait()與notify()來控制執行緒執行的個數。

注意：條件鎖可以自由設定一次放行幾個執行緒。

下面是threading模組與條件鎖提供的相關方法：

方法	描述
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()	通知所有當前狀態為“等待”的執行緒繼續執行

使用方式

下面這個案例會啟動10個子執行緒，並且會立即將10個子執行緒設定為等待狀態。

然後我們可以傳送一個或者多個通知，來恢復被等待的子執行緒繼續執行：

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語句

由於threading.Condition()物件中實現了__enter__()與__exit__()方法，故我們可以使用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")

Event() 事件鎖

基本介紹

事件鎖是基於條件鎖來做的，它與條件鎖的區別在於一次只能放行全部，不能放行任意個數量的子執行緒繼續執行。

我們可以將事件鎖看為紅綠燈，當紅燈時所有子執行緒都暫停執行，並進入“等待”狀態，當綠燈時所有子執行緒都恢復“執行”。

下面是threading模組與事件鎖提供的相關方法：

方法	描述
threading.Event()	返回一個事件鎖物件
lockObject.clear()	將事件鎖設為紅燈狀態，即所有執行緒暫停執行
lockObject.is_set()	用來判斷當前事件鎖狀態，紅燈為False，綠燈為True
lockObject.set()	將事件鎖設為綠燈狀態，即所有執行緒恢復執行
lockObject.wait(timeout=None)	將當前執行緒設定為“等待”狀態，只有該執行緒接到“綠燈通知”或者超時時間到期之後才會繼續執行，在“等待”狀態下的執行緒將允許系統根據策略自行切換到其他執行緒中執行

使用方式

事件鎖不能利用with語句來進行使用，只能按照常規方式。

如下所示，我們來模擬執行緒和紅綠燈的操作，紅燈停，綠燈行：

import threading

maxSubThreadNumber = 3


def task():
    thName = threading.currentThread().name
    print("start and wait run thread : %s" % thName)
    eventLock.wait()  # 暫停執行，等待綠燈
    print("green light, %s carry on run" % thName)
    print("red light, %s stop run" % thName)
    eventLock.wait()  # 暫停執行，等待綠燈
    print("green light, %s carry on run" % thName)
    print("sub thread %s run end" % thName)


if __name__ == "__main__":

    eventLock = threading.Event()

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

    eventLock.set()  # 設定為綠燈
    eventLock.clear()  # 設定為紅燈
    eventLock.set()  # 設定為綠燈

# start and wait run thread : Thread-1
# start and wait run thread : Thread-2
# start and wait run thread : Thread-3

# green light, Thread-1 carry on run
# red light, Thread-1 stop run
# green light, Thread-1 carry on run
# sub thread Thread-1 run end

# green light, Thread-3 carry on run
# red light, Thread-3 stop run
# green light, Thread-3 carry on run
# sub thread Thread-3 run end

# green light, Thread-2 carry on run
# red light, Thread-2 stop run
# green light, Thread-2 carry on run
# sub thread Thread-2 run end

Semaphore() 訊號量鎖

基本介紹

訊號量鎖也是根據條件鎖來做的，它與條件鎖和事件鎖的區別如下：

條件鎖：一次可以放行任意個處於“等待”狀態的執行緒
事件鎖：一次可以放行全部的處於“等待”狀態的執行緒
訊號量鎖：通過規定，成批的放行特定個處於“上鎖”狀態的執行緒

下面是threading模組與訊號量鎖提供的相關方法：

方法	描述
threading.Semaphore()	返回一個訊號量鎖物件
lockObject.acquire(blocking=True, timeout=1)	上鎖，當一個執行緒在執行被上鎖程式碼塊時，將不允許切換到其他執行緒執行，預設鎖失效時間為1秒
lockObject.release()	解鎖，當一個執行緒在執行未被上鎖程式碼塊時，將允許系統根據策略自行切換到其他執行緒中執行

使用方式

以下是使用示例，你可以將它當做一段限寬的路段，每次只能放行相同數量的執行緒：

import threading
import time

maxSubThreadNumber = 6


def task():
    thName = threading.currentThread().name
    semaLock.acquire()
    print("run sub thread %s" % thName)
    time.sleep(3)
    semaLock.release()


if __name__ == "__main__":
    # 每次只能放行2個
    semaLock = threading.Semaphore(2)

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


# run sub thread Thread-1
# run sub thread Thread-2

# run sub thread Thread-3
# run sub thread Thread-4

# run sub thread Thread-6
# run sub thread Thread-5

with語句

由於threading.Semaphore()物件中實現了__enter__()與__exit__()方法，故我們可以使用with語句進行上下文管理形式的加鎖解鎖操作：

import threading
import time

maxSubThreadNumber = 6


def task():
    thName = threading.currentThread().name
    with semaLock:
        print("run sub thread %s" % thName)
        time.sleep(3)


if __name__ == "__main__":

    semaLock = threading.Semaphore(2)

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

鎖關係淺析

上面5種鎖可以說都是基於同步鎖來做的，這些你都可以從原始碼中找到答案。

首先來看RLock遞迴鎖，遞迴鎖的實現非常簡單，它的內部會維護著一個計數器，當計數器不為0的時候該執行緒不能被I/O操作和時間輪詢機制切換。但是當計數器為0的時候便不會如此了：

def __init__(self):
    self._block = _allocate_lock()
    self._owner = None
    self._count = 0  # 計數器

而Condition條件鎖的內部其實是有兩把鎖的，一把底層鎖（同步鎖）一把高階鎖(遞迴鎖)。

低層鎖的解鎖方式有兩種，使用wait()方法會暫時解開底層鎖同時加上一把高階鎖，只有當接收到別的執行緒裡的notfiy()後才會解開高階鎖和重新上鎖低層鎖，也就是說條件鎖底層是根據同步鎖和遞迴鎖的不斷切換來進行實現的：

def __init__(self, lock=None):
    if lock is None:
        lock = RLock()  # 可以看到條件鎖的內部是基於遞迴鎖，而遞迴鎖又是基於同步鎖來做的
    self._lock = lock

    self.acquire = lock.acquire
    self.release = lock.release
    try:
        self._release_save = lock._release_save
    except AttributeError:
        pass
    try:
        self._acquire_restore = lock._acquire_restore
    except AttributeError:
        pass
    try:
        self._is_owned = lock._is_owned
    except AttributeError:
        pass
    self._waiters = _deque()

Event事件鎖內部是基於條件鎖來做的：

class Event:

    def __init__(self):
        self._cond = Condition(Lock())  # 例項化出了一個條件鎖。
        self._flag = False

    def _reset_internal_locks(self):
        # private!  called by Thread._reset_internal_locks by _after_fork()
        self._cond.__init__(Lock())

    def is_set(self):
        """Return true if and only if the internal flag is true."""
        return self._flag

    isSet = is_set

Semaphore訊號量鎖內部也是基於條件鎖來做的：

class Semaphore:

    def __init__(self, value=1):
        if value < 0:
            raise ValueError("semaphore initial value must be >= 0")
        self._cond = Condition(Lock()) # 可以看到，這裡是例項化出了一個條件鎖
        self._value = value

基本練習題

條件鎖的應用

需求：一個空列表，兩個執行緒輪番往裡面加值（一個加偶數，一個加奇數），最終讓該列表中的值為 1 - 100 ，且是有序排列的。

import threading

lst = []


def even():
    """加偶數"""
    with condLock:
        for i in range(2, 101, 2):
            # 判斷當前列表的長度處於2是否能處盡
            # 如果能處盡則代表需要新增奇數
            # 否則就新增偶數
            if len(lst) % 2 != 0:
                # 添偶數
                lst.append(i)      # 先新增值
                condLock.notify()  # 告訴另一個執行緒，你可以加奇數了，但是這裡不會立即交出執行權
                condLock.wait()    # 交出執行權，並等待另一個執行緒通知加偶數
            else:
                # 添奇數
                condLock.wait()  # 交出執行權，等待另一個執行緒通知加偶數
                lst.append(i)    
                condLock.notify()
        condLock.notify()


def odd():
    """加奇數"""
    with condLock:
        for i in range(1, 101, 2):
            if len(lst) % 2 == 0:
                lst.append(i)
                condLock.notify()
                condLock.wait()
        condLock.notify()


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

    addEvenTask = threading.Thread(target=even)
    addOddTask = threading.Thread(target=odd)

    addEvenTask.start()
    addOddTask.start()

    addEvenTask.join()
    addOddTask.join()

    print(lst)

事件鎖的應用

有2個任務執行緒來扮演李白和杜甫，如何讓他們一人一句進行對答？文字如下：

杜甫：老李啊，來喝酒！

李白：老杜啊，不喝了我喝不下了！

杜甫：老李啊，再來一壺？

杜甫：...老李？

李白：呼呼呼...睡著了..

程式碼如下：

import threading


def libai():
    event.wait()  
    print("李白：老杜啊，不喝了我喝不下了！")
    event.set()
    event.clear()
    event.wait()
    print("李白：呼呼呼...睡著了..")

def dufu():
    print("杜甫：老李啊，來喝酒！")
    event.set()  
    event.clear()
    event.wait()
    print("杜甫：老李啊，再來一壺？")
    print("杜甫：...老李？")
    event.set()


if __name__ == '__main__':

    event = threading.Event()

    t1 = threading.Thread(target=libai)
    t2 = threading.Thread(target=dufu)

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

Java中執行緒池，你真的會用嗎？
2018-10-31
Java執行緒
python中5種執行緒鎖
2024-02-28
Python執行緒
iOS多執行緒安全-13種執行緒鎖?
2018-11-19
iOS執行緒
OC 各種執行緒鎖
2017-12-13
執行緒
IO多路複用和多執行緒會影響Redis分散式鎖嗎？
2023-03-18
執行緒Redis分散式
你真的會用mysql行級鎖嗎？mysql 行級鎖全解析
2019-07-08
MySql
你會這道阿里多執行緒面試題嗎？
2019-03-19
阿里執行緒面試題
比物理執行緒都好用的C++20的協程，你會用嗎？
2021-05-17
執行緒C++
【java】【多執行緒】建立執行緒的兩種常用方式（2）
2018-04-15
Java執行緒
java多執行緒（5）死鎖
2018-03-26
Java執行緒
執行緒安全: 互斥鎖和自旋鎖(10種)
2018-11-19
執行緒
.NET中各種執行緒同步鎖
2024-08-18
執行緒
Java 執行緒的5種狀態
2020-11-19
Java執行緒
乾飯人！多執行緒鎖分類你不看看嗎？肆
2020-12-05
執行緒
你會執行指令碼嗎
2015-05-22
指令碼
Java執行緒：執行緒的同步與鎖
2017-11-14
Java執行緒
小夥子，你懂執行緒池的建立嗎？
2020-07-12
執行緒
執行緒同步及執行緒鎖
2018-01-01
執行緒
執行緒的互斥鎖
2024-05-29
執行緒
ObjC 多執行緒簡析（一）-多執行緒簡述和執行緒鎖的基本應用
2019-02-28
OBJ執行緒
Java多執行緒（2）執行緒鎖
2019-07-09
Java執行緒
Java多執行緒5：synchronized鎖方法塊
2015-10-03
Java執行緒synchronized
多執行緒的這些鎖知道嗎？手寫一個自旋鎖？
2021-07-08
執行緒
java 執行緒鎖物件鎖的理解
2017-04-18
Java執行緒物件
多執行緒_鎖
2022-02-09
執行緒
執行緒鎖（四）
2020-10-04
執行緒
知道執行緒池的四種拒絕策略嗎?
2020-10-29
執行緒
執行緒中的死鎖
2020-10-16
執行緒
多執行緒,執行緒類三種方式,執行緒排程,執行緒同步,死鎖,執行緒間的通訊,阻塞佇列,wait和sleep區別?
2021-01-03
執行緒佇列AI
你都理解建立執行緒池的引數嗎？
2019-04-11
執行緒
python3執行緒中的事件Event怎麼用？
2021-09-11
Python執行緒事件
python3 多執行緒
2019-10-18
Python執行緒
java多執行緒程式設計：你真的瞭解執行緒中斷嗎？
2024-06-14
Java執行緒程式設計
執行緒和鎖,鎖升級
2020-11-15
執行緒
你的單例模式真的是執行緒安全的嗎?
2018-10-10
單例模式執行緒
多執行緒（2）-執行緒同步互斥鎖Mutex
2024-04-04
執行緒Mutex
Java程式猿必會的四種執行緒池
2019-07-10
Java執行緒
執行緒、開啟執行緒的兩種方式、執行緒下的Join方法、守護執行緒
2024-06-25
執行緒

Python3中最常用的5種執行緒鎖你會用嗎

前言

執行緒安全

鎖的作用

Lock() 同步鎖

基本介紹

使用方式

死鎖現象

with語句

RLock() 遞迴鎖

基本介紹

使用方式

with語句

Condition() 條件鎖

基本介紹

使用方式

with語句

Event() 事件鎖

基本介紹

使用方式

Semaphore() 訊號量鎖

基本介紹

使用方式

with語句

鎖關係淺析

基本練習題

條件鎖的應用

事件鎖的應用

相關文章