1.添加超時時間：

fromthreading import Thread, Lock
importtime 
mutex1= Lock()  # 創(chuàng)建一個互斥鎖
mutex2= Lock()  # 創(chuàng)建一個互斥鎖

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()
            break
        else:
            # 表示對mutex2上鎖失敗
           mutex1.release()  # 將mutex1釋放，保證別人能夠執(zhí)行
            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.附錄-銀行家算法（ 不要求，理解就可以）

背景知識

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

問題的描述

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

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

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

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

補充：python基礎(chǔ)-死鎖、遞歸鎖

死鎖

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

from threading import Thread,Lock
import time
mutexA=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鎖

分析如上代碼是如何產(chǎn)生死鎖的：

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

遞歸鎖

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

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

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

from threading import Thread,Lock,RLock
import time
mutexA=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:\python\python_sdk\python.exe "E:/python/py_pro/3 死鎖現(xiàn)象與遞歸鎖.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的次數(shù)2次，然后在func1執(zhí)行完畢，就釋放遞歸鎖，在thread1釋放完遞歸鎖，執(zhí)行完func1代碼，接下來會有2種可能，1、thread1在次搶到遞歸鎖，執(zhí)行func2代碼 2、其他的線程搶到遞歸鎖，去執(zhí)行func1的任務(wù)代碼

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。

最新評論