python實現死鎖和重入鎖

import threading

import time
class
mythread1
(threading.thread)
:def
run(self)
:# 對mutexa上鎖
mutexa.acquire(
)# mutexa上鎖後，延時1秒，等待另外那個執行緒 把mutexb上鎖
print
(self.name+
'----do1---up----'
)        time.sleep(1)
# 此時會堵塞，因為這個mutexb已經被另外的執行緒搶先上鎖了
mutexb.acquire(
)print
(self.name+
'----do1---down----'
)        mutexb.release(
)# 對mutexa解鎖
mutexa.release(
)class
mythread2
(threading.thread)
:def
run(self)
:# 對mutexb上鎖
mutexb.acquire(
)# mutexb上鎖後，延時1秒，等待另外那個執行緒 把mutexa上鎖
print
(self.name+
'----do2---up----'
)        time.sleep(1)
# 此時會堵塞，因為這個mutexa已經被另外的執行緒搶先上鎖了
mutexa.acquire(
)print
(self.name+
'----do2---down----'
)        mutexa.release(
)# 對mutexb解鎖
mutexb.release(
)mutexa = threading.lock(
)mutexb = threading.lock(
)if __name__ ==
'__main__'
:    t1 = mythread1(
)    t2 = mythread2(
)    t1.start(
)    t2.start(
)

乙個執行緒給a上鎖，另乙個再給a上鎖時就阻塞了

def

add1
(nums,mutex)
:global num
mutex.acquire(
)    mutex.acquire(
)for i in
range
(nums)
:        num+=
1    mutex.release(
)    mutex.release(
)#這樣就會阻塞，不會向下進行
#time.sleep(1)
print
(f'-----add1----'
)

def

main()
:# mutex = threading.lock()
mutex = threading.rlock(
)#重入鎖  可以解決多把鎖阻塞的問題
t1 = threading.thread(target=add1,args=
(1000000
,mutex)
)    t2 = threading.thread(target=add2,args=
(1000000
,mutex)
)    t1.start(
)#time.sleep(1)
t2.start(
)    t1.join(
)    t2.join(
)print
(f'-----main-----'
)

python多執行緒程式設計 4 死鎖和可重入鎖

encoding utf 8 import threading import time class mythread threading.thread def do1 self global resa,resb if mutexa.acquire msg self.name got resa pri...

可重入鎖和不可重入鎖

當乙個執行緒獲得當前例項的鎖lock，並且進入了方法a，該執行緒在方法a沒有釋放該鎖的時候，是否可以再次進入使用該鎖的方法b？不可重入鎖 在方法a釋放鎖之前，不可以再次進入方法b 可重入鎖 在方法a釋放該鎖之前可以再次進入方法b 如reentrantlock和synchronized 不可重入鎖的實...

可重入鎖和不可重入鎖

可重入鎖就是可以迴圈迭代使用的鎖，不會產生死鎖的現象，典型的就是synchronized和reentrantlock。不可重入鎖迴圈迭代使用則有產生死鎖的風險。可重入鎖 class reentranttest implements runnable public synchronized void ...