互斥鎖死鎖遞迴鎖訊號量 GIL鎖

互斥鎖lock也是一種阻塞，可以保證共享資料操作的完整性。保證在任一時刻，只能有乙個執行緒訪問該物件

from multiprocessing import process
from threading import thread
from multiprocessing import lock # 程序鎖
# from threading import lock # 執行緒鎖
import time
defa
(lock)
:    lock.acquire(
)# 加鎖
print
("p1前"
)    time.sleep(1)
print
("p1後"
)    lock.release(
)# 解鎖
defb
(lock)
:    lock.acquire(
)# 加鎖
print
("p2前"
)    time.sleep(1)
print
("p2後"
)    lock.release(
)# 解鎖
if __name__ ==
'__main__'
:    lock = lock(
)# 建立乙個鎖
p1 = process(target=a,args=
(lock,))
p2 = process(target=b,args=
(lock,))
p1.start(
)    p2.start(
)

是指兩個或兩個以上的程序或執行緒在執行過程中，因爭奪資源而造成的一種互相等待的現象，若無外力作用，它們都將無法推進下去。此時稱系統處於死鎖狀態或系統產生了死鎖，這些永遠在互相等待的程序稱為死鎖程序

from threading import thread
from threading import lock
import time
locka = lock(
)lockb = lock(
)class
te(thread)
:def
run(self)
:        self.a(
)        self.b(
)def
a(self)
:        locka.acquire(
)print
(f"拿到a鎖"
)        lockb.acquire(
)print
(f"拿到b鎖"
)        lockb.release(
)print
(f"釋放b鎖"
)        locka.release(
)print
(f"釋放a鎖"
)def
b(self)
:        lockb.acquire(
)print
(f"拿到b鎖"
)        time.sleep(
0.1)
locka.acquire(
)print
(f"拿到a鎖"
)        locka.release(
)print
(f"釋放a鎖"
)        lockb.release(
)print
(f"釋放b鎖"
)if __name__ ==
'__main__'
:for i in
range(3
):t = te(
)        t.start(
)

遞迴鎖rlock可以解決死鎖問題，遞迴鎖有乙個計數器，每次上鎖都會加一，解鎖會減一，直到計數器為零時其他程序才可以進行搶鎖

from threading import thread
from threading import rlock
import time
locka = lockb = rlock(
)# 建立格式
class
te(thread)
:def
run(self)
:        self.a(
)        self.b(
)def
a(self)
:        locka.acquire(
)print
(f"拿到a鎖"
)        lockb.acquire(
)print
(f"拿到b鎖"
)        lockb.release(
)print
(f"釋放b鎖"
)        locka.release(
)print
(f"釋放a鎖"
)def
b(self)
:        lockb.acquire(
)print
(f"拿到b鎖"
)        time.sleep(
0.1)
locka.acquire(
)print
(f"拿到a鎖"
)        locka.release(
)print
(f"釋放a鎖"
)        lockb.release(
)print
(f"釋放b鎖"
)if __name__ ==
'__main__'
:for i in
range(3
):t = te(
)        t.start(
)

semaphore管理乙個內建的計數器，每當呼叫acquire()時內建計數器-1；呼叫release() 時內建計數器+1；計數器不能小於0；當計數器為0時，acquire()將阻塞執行緒直到其他執行緒呼叫release()。

from threading import thread,semaphore
import time
sem = semaphore(2)
defa
(name)
:    sem.acquire(
)print
(name)
time.sleep(2)
sem.release(
)if __name__ ==
'__main__'
:for i in
range(5
):t = thread(target=a,args=
(f"執行緒",)
)        t.start(
)

gil鎖是乙個直譯器級別的鎖，保證了同一時刻只能乙個執行緒進入直譯器，jpyhon和pypy都沒有gil鎖，保證了cpython直譯器的資料資源安全的同時，也使單程序多執行緒的程式不能利用多核

gil鎖和lock鎖的區別

互斥鎖，遞迴鎖，訊號量

互斥鎖，遞迴鎖，訊號量以上都是程序執行緒鎖，下面我就一一解釋一下最普通互斥鎖 from threading import thread,lock import time defwork l.acquire time.sleep 1 print ok l.release if name mai...

死鎖，遞迴鎖，訊號量

對同一把鎖多次acquire將導致死鎖，可以給acquire加上超時 timeout 來保證執行緒不被卡死。from threading import lock l lock l.acquire l.acquire timeout 3 乙個共享資源，要訪問必須同時具備多把鎖，但是這些鎖被不同的程序或...

自旋鎖，互斥鎖，訊號量

自旋鎖，互斥鎖，訊號量樂觀鎖和悲觀鎖只是一種理論，是從思想上劃分的。自旋鎖和互斥鎖是應用層確確實實的鎖，用於同步訪問控制如果一定要劃分，從只有乙個執行緒可以擁有鎖來說，我覺得自旋鎖和互斥鎖應該都屬於悲觀鎖，因為一般的應用不需要支援事物回滾的操作。但是沈詢的直播中說，互斥鎖屬於悲觀鎖 sleep ...

互斥鎖 死鎖 遞迴鎖 訊號量 GIL鎖

互斥鎖，遞迴鎖，訊號量

死鎖，遞迴鎖，訊號量

自旋鎖，互斥鎖，訊號量

相關推薦

互斥鎖死鎖遞迴鎖訊號量 GIL鎖