fromthreading import Thread, Lockimporttime mutex1= Lock() # 創建一個互斥鎖mutex2= Lock() # 創建一個互斥鎖

def fun1(): while True:mutex1.acquire()print('線程1 鎖住了mutex1')time.sleep(0.1) result =mutex2.acquire(timeout=1) # timeout指明acquire等的最長超時時間# result = mutex2.acquire(False) # 非阻塞if result: # 表示對mutex2成功上鎖 print('線程1 鎖住了mutex2') print('線程1 hello') mutex1.release() mutex2.release() breakelse: # 表示對mutex2上鎖失敗 mutex1.release() # 將mutex1釋放，保證別人能夠執行 time.sleep(0.1)

def fun2(): mutex2.acquire() print('線程2 鎖住了mutex2') time.sleep(0.1) mutex1.acquire() print('線程2 鎖住了mutex1') print('線程2 hi') mutex1.release() mutex2.release()2.附錄-銀行家算法（ 不要求，理解就可以）背景知識

一個銀行家如何將一定數目的資金安全地借給若干個客戶，使這些客戶既能借到錢完成要干的事，同時銀行家又能收回全部資金而不至于破產，這就是銀行家問題。這個問題同操作系統中資源分配問題十分相似：銀行家就像一個操作系統，客戶就像運行的進程，銀行家的資金就是系統的資源。

一個銀行家擁有一定數量的資金，有若干個客戶要貸款。每個客戶須在一開始就聲明他所需貸款的總額。若該客戶貸款總額不超過銀行家的資金總數，銀行家可以接收客戶的要求。客戶貸款是以每次一個資金單位（如1萬RMB等）的方式進行的，客戶在借滿所需的全部單位款額之前可能會等待，但銀行家須保證這種等待是有限的，可完成的。

例如：有三個客戶C1，C2，C3，向銀行家借款，該銀行家的資金總額為10個資金單位，其中C1客戶要借9各資金單位，C2客戶要借3個資金單位，C3客戶要借8個資金單位，總計20個資金單位。某一時刻的狀態如圖所示。

對于a圖的狀態，按照安全序列的要求，我們選的第一個客戶應滿足該客戶所需的貸款小于等于銀行家當前所剩余的錢款，可以看出只有C2客戶能被滿足：C2客戶需1個資金單位，小銀行家手中的2個資金單位，于是銀行家把1個資金單位借給C2客戶，使之完成工作并歸還所借的3個資金單位的錢，進入b圖。同理，銀行家把4個資金單位借給C3客戶，使其完成工作，在c圖中，只剩一個客戶C1，它需7個資金單位，這時銀行家有8個資金單位，所以C1也能順利借到錢并完成工作。最后（見圖d）銀行家收回全部10個資金單位，保證不賠本。那麼客戶序列{C1，C2，C3}就是個安全序列，按照這個序列貸款，銀行家才是安全的。否則的話，若在圖b狀態時，銀行家把手中的4個資金單位借給了C1，則出現不安全狀態：這時C1，C3均不能完成工作，而銀行家手中又沒有錢了，系統陷入僵持局面，銀行家也不能收回投資。

綜上所述，銀行家算法是從當前狀態出發，逐個按安全序列檢查各客戶誰能完成其工作，然后假定其完成工作且歸還全部貸款，再進而檢查下一個能完成工作的客戶，......。如果所有客戶都能完成工作，則找到一個安全序列，銀行家才是安全的。

補充：python基礎-死鎖、遞歸鎖

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

from threading import Thread,Lockimport timemutexA=Lock()mutexB=Lock()class MyThread(Thread): def run(self):self.func1()self.func2() def func1(self):mutexA.acquire()print(’033[41m%s 拿到A鎖033[0m’ %self.name)mutexB.acquire()print(’033[42m%s 拿到B鎖033[0m’ %self.name)mutexB.release()mutexA.release() def func2(self):mutexB.acquire()print(’033[43m%s 拿到B鎖033[0m’ %self.name)time.sleep(2)mutexA.acquire()print(’033[44m%s 拿到A鎖033[0m’ %self.name)mutexA.release()mutexB.release()if __name__ == ’__main__’: for i in range(5):t=MyThread()t.start()

輸出如下：

Thread-1 拿到A鎖

Thread-1 拿到B鎖

Thread-1 拿到B鎖

Thread-2 拿到A鎖

分析如上代碼是如何產生死鎖的：

啟動5個線程，執行run方法，假如thread1首先搶到了A鎖，此時thread1沒有釋放A鎖，緊接著執行代碼mutexB.acquire()，搶到了B鎖，在搶B鎖時候，沒有其他線程與thread1爭搶，因為A鎖沒有釋放，其他線程只能等待，然后A鎖就執行完func1代碼，然后繼續執行func2代碼，與之同時，在func2中，執行代碼 mutexB.acquire()，搶到了B鎖，然后進入睡眠狀態，在thread1執行完func1函數，釋放AB鎖時候，其他剩余的線程也開始搶A鎖，執行func1代碼，如果thread2搶到了A鎖，接下來thread2要搶B鎖，ok，在這個時間段，thread1已經執行func2搶到了B鎖，然后在sleep(2),持有B鎖沒有釋放，為什么沒有釋放，因為沒有其他的線程與之爭搶，他只能睡著，然后thread1握著B鎖，thread2要搶B鎖，ok，這樣就形成了死鎖

我們分析了死鎖，那么python里面是如何解決這樣的遞歸鎖呢？

在Python中為了支持在同一線程中多次請求同一資源，python提供了可重入鎖RLock。

這個RLock內部維護著一個Lock和一個counter變量，counter記錄了acquire的次數，從而使得資源可以被多次require。直到一個線程所有的acquire都被release，其他的線程才能獲得資源。上面的例子如果使用RLock代替Lock，則不會發生死鎖：

from threading import Thread,Lock,RLockimport timemutexA=mutexB=RLock()class MyThread(Thread): def run(self):self.f1()self.f2() def f1(self):mutexA.acquire()print(’%s 拿到A鎖’ %self.name)mutexB.acquire()print(’%s 拿到B鎖’ %self.name)mutexB.release()mutexA.release() def f2(self):mutexB.acquire()print(’%s 拿到B鎖’ % self.name)time.sleep(0.1)mutexA.acquire()print(’%s 拿到A鎖’ % self.name)mutexA.release()mutexB.release()if __name__ == ’__main__’: for i in range(5):t=MyThread()t.start()

輸出代碼如下：

E:pythonpython_sdkpython.exe 'E:/python/py_pro/3 死鎖現象與遞歸鎖.py'

Thread-1 拿到A鎖

Thread-1 拿到B鎖

Thread-1 拿到B鎖

Thread-1 拿到A鎖

Thread-2 拿到A鎖

Thread-2 拿到B鎖

Thread-2 拿到B鎖

Thread-2 拿到A鎖

Thread-4 拿到A鎖

Thread-4 拿到B鎖

Thread-4 拿到B鎖

Thread-4 拿到A鎖

Thread-3 拿到A鎖

Thread-3 拿到B鎖

Thread-3 拿到B鎖

Thread-3 拿到A鎖

Thread-5 拿到A鎖

Thread-5 拿到B鎖

Thread-5 拿到B鎖

Thread-5 拿到A鎖

Process finished with exit code 0

或者如下的效果：

來解釋下遞歸鎖的代碼：

由于鎖A，B是同一個遞歸鎖，thread1拿到A,B鎖，counter記錄了acquire的次數2次，然后在func1執行完畢，就釋放遞歸鎖，在thread1釋放完遞歸鎖，執行完func1代碼，接下來會有2種可能，1、thread1在次搶到遞歸鎖，執行func2代碼 2、其他的線程搶到遞歸鎖，去執行func1的任務代碼

以上為個人經驗，希望能給大家一個參考，也希望大家多多支持好吧啦網。如有錯誤或未考慮完全的地方，望不吝賜教。