互斥鎖遞迴鎖及死鎖現象

from threading import lock,rlock

# lock 互斥鎖    效率高
# rlock 遞迴(recursion)鎖  效率相對低
l = lock()
l.acquire()
print('希望被鎖住的**')
l.release()
rl = rlock()  # 在同乙個執行緒中可以被acquire多次
rl.acquire()
print('希望被鎖住的**')
rl.release()

from threading import thread,rlock as lock

def func(i,lock):
lock.acquire()
lock.acquire()
print(i,': start')
lock.release()
lock.release()
print(i, ': end')
lock = lock()
for i in range(5):
thread(target=func,args=(i,lock)).start()

import time

from threading import thread,lock,rlock
# fork_lock = noodle_lock = rlock()
noodle_lock = rlock()
fork_lock = rlock()
def eat(name):
noodle_lock.acquire()
print(name,'搶到面了')
fork_lock.acquire()
print(name, '搶到叉子了')
print(name,'吃麵')
time.sleep(0.1)
fork_lock.release()
print(name, '放下叉子了')
noodle_lock.release()
print(name, '放下面了')
def eat2(name):
fork_lock.acquire()
print(name, '搶到叉子了')
noodle_lock.acquire()
print(name,'搶到面了')
print(name,'吃麵')
noodle_lock.release()
print(name, '放下面了')
fork_lock.release()
print(name, '放下叉子了')
thread(target=eat,args=('alex',)).start()
thread(target=eat2,args=('wusir',)).start()
thread(target=eat,args=('taibai',)).start()
thread(target=eat2,args=('大壯',)).start()

多把(互斥/遞迴)鎖 並且在多個執行緒中 交叉使用

fork_lock.acquire()

noodle_lock.acquire()

fork_lock.release()

noodle_lock.release()

如果是互斥鎖,出現了死鎖現象,最快速的解決方案把所有的互斥鎖都改成一把遞迴鎖

程式的效率會降低的

遞迴鎖 效率低 但是解決死鎖現象有奇效

互斥鎖 效率高 但是多把鎖容易出現死鎖現象

鎖 互斥鎖，死鎖

當多個執行緒幾乎同時修改某乙個共享資料的時候，需要進行同步控制 執行緒同步能夠保證多個執行緒安全訪問競爭資源，最簡單的同步機制是引入互斥鎖。互斥鎖為資源引入乙個狀態 鎖定 非鎖定 某個執行緒要更改共享資料時，先將其鎖定，此時資源的狀態為 鎖定 其他執行緒不能更改 直到該執行緒釋放資源，將資源的狀態變...

3 7 死鎖現象和遞迴鎖

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

Python 互斥鎖 遞迴鎖 死鎖機制詳解

互斥鎖 犧牲了執行效率而獲得資料安全 問題 多個執行緒搶占資源,會發生資料混亂 from threading import thread import os,time def work global n temp n time.sleep 0.1 n temp 1 if name main n 10...