一、死鎖
簡單來說，死鎖是一個資源被多次調(diào)用，而多次調(diào)用方都未能釋放該資源就會造成死鎖，這里結(jié)合例子說明下兩種常見的死鎖情況。
1、迭代死鎖
該情況是一個線程“迭代”請求同一個資源，直接就會造成死鎖：
import threading
import time
class MyThread(threading.Thread):
def run(self):
global num
time.sleep(1)
if mutex.acquire(1):
num = num+1
msg = self.name+' set num to '+str(num)
print msg
mutex.acquire()
mutex.release()
mutex.release()
num = 0
mutex = threading.Lock()
def test():
for i in range(5):
t = MyThread()
t.start()
if __name__ == '__main__':
test()
上例中，在run函數(shù)的if判斷中第一次請求資源，請求后還未 release ，再次acquire，最終無法釋放，造成死鎖。這里例子中通過將print下面的兩行注釋掉就可以正常執(zhí)行了 ，除此之外也可以通過可重入鎖解決，后面會提到。
2、互相調(diào)用死鎖
上例中的死鎖是在同一個def函數(shù)內(nèi)多次調(diào)用造成的，另一種情況是兩個函數(shù)中都會調(diào)用相同的資源，互相等待對方結(jié)束的情況。如果兩個線程分別占有一部分資源并且同時等待對方的資源，就會造成死鎖。
import threading
import time
class MyThread(threading.Thread):
def do1(self):
global resA, resB
if mutexA.acquire():
msg = self.name+' got resA'
print msg
if mutexB.acquire(1):
msg = self.name+' got resB'
print msg
mutexB.release()
mutexA.release()
def do2(self):
global resA, resB
if mutexB.acquire():
msg = self.name+' got resB'
print msg
if mutexA.acquire(1):
msg = self.name+' got resA'
print msg
mutexA.release()
mutexB.release()
def run(self):
self.do1()
self.do2()
resA = 0
resB = 0
mutexA = threading.Lock()
mutexB = threading.Lock()
def test():
for i in range(5):
t = MyThread()
t.start()
if __name__ == '__main__':
test()
這個死鎖的示例稍微有點復(fù)雜。具體可以理下。
二、可重入鎖
為了支持在同一線程中多次請求同一資源，python提供了“可重入鎖”：threading.RLock。RLock內(nèi)部維護(hù)著一個Lock和一個counter變量，counter記錄了acquire的次數(shù)，從而使得資源可以被多次require。直到一個線程所有的acquire都被release，其他的線程才能獲得資源。這里以例1為例，如果使用RLock代替Lock，則不會發(fā)生死鎖：
import threading
import time
class MyThread(threading.Thread):
def run(self):
global num
time.sleep(1)
if mutex.acquire(1):
num = num+1
msg = self.name+' set num to '+str(num)
print msg
mutex.acquire()
mutex.release()
mutex.release()
num = 0
mutex = threading.RLock()
def test():
for i in range(5):
t = MyThread()
t.start()
if __name__ == '__main__':
test()
和上面那個例子的不同之處在于threading.Lock()換成了threading.RLock() 。
三、互斥鎖
python threading模塊有兩類鎖：互斥鎖（threading.Lock ）和可重用鎖（threading.RLock）。兩者的用法基本相同，具體如下：
lock = threading.Lock()
lock.acquire()
dosomething……
lock.release()
RLock的用法是將threading.Lock()修改為threading.RLock()。便于理解，先來段代碼：
[root@361way lock]# cat lock1.py
#!/usr/bin/env python
# coding=utf-8
import threading # 導(dǎo)入threading模塊
import time # 導(dǎo)入time模塊
class mythread(threading.Thread): # 通過繼承創(chuàng)建類
def __init__(self,threadname): # 初始化方法
# 調(diào)用父類的初始化方法
threading.Thread.__init__(self,name = threadname)
def run(self): # 重載run方法
global x # 使用global表明x為全局變量
for i in range(3):
x = x + 1
time.sleep(5) # 調(diào)用sleep函數(shù)，讓線程休眠5秒
print x
tl = [] # 定義列表
for i in range(10):
t = mythread(str(i)) # 類實例化
tl.append(t) # 將類對象添加到列表中
x=0 # 將x賦值為0
for i in tl:
i.start()
這里執(zhí)行的結(jié)果和想想的不同，結(jié)果如下：
[root@361way lock]# python lock1.py
30
30
30
30
30
30
30
30
30
30
為什么結(jié)果都是30呢？關(guān)鍵在于global 行和 time.sleep行。
1、由于x是一個全局變量，所以每次循環(huán)后 x 的值都是執(zhí)行后的結(jié)果值；
2、由于該代碼是多線程的操作，所以在sleep 等待的時候，之前已經(jīng)執(zhí)行完成的線程會在這等待，而后續(xù)的進(jìn)程在等待的5秒這段時間也執(zhí)行完成 ，等待print。同樣由于global 的原理，x被重新斌值。所以打印出的結(jié)果全是30 ；
3、便于理解，可以嘗試將sleep等注釋，你再看下結(jié)果，就會發(fā)現(xiàn)有不同。
在實際應(yīng)用中，如抓取程序等，也會出現(xiàn)類似于sleep等待的情況。在前后調(diào)用有順序或打印有輸出的時候，就會現(xiàn)并發(fā)競爭，造成結(jié)果或輸出紊亂。這里就引入了鎖的概念，上面的代碼修改下，如下：
[root@361way lock]# cat lock2.py
#!/usr/bin/env python
# coding=utf-8
import threading # 導(dǎo)入threading模塊
import time # 導(dǎo)入time模塊
class mythread(threading.Thread): # 通過繼承創(chuàng)建類
def __init__(self,threadname): # 初始化方法
threading.Thread.__init__(self,name = threadname)
def run(self): # 重載run方法
global x # 使用global表明x為全局變量
lock.acquire() # 調(diào)用lock的acquire方法
for i in range(3):
x = x + 1
time.sleep(5) # 調(diào)用sleep函數(shù)，讓線程休眠5秒
print x
lock.release() # 調(diào)用lock的release方法
lock = threading.Lock() # 類實例化
tl = [] # 定義列表
for i in range(10):
t = mythread(str(i)) # 類實例化
tl.append(t) # 將類對象添加到列表中
x=0 # 將x賦值為0
for i in tl:
i.start() # 依次運(yùn)行線程
執(zhí)行的結(jié)果如下：
[root@361way lock]# python lock2.py
3
6
9
12
15
18
21
24
27
30
加鎖的結(jié)果會造成阻塞，而且會造成開鎖大。會根據(jù)順序由并發(fā)的多線程按順序輸出，如果后面的線程執(zhí)行過快，需要等待前面的進(jìn)程結(jié)束后其才能結(jié)束 －－－ 寫的貌似有點像隊列的概念了 ，不過在加鎖的很多場景下確實可以通過隊列去解決。
更多文章、技術(shù)交流、商務(wù)合作、聯(lián)系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯(lián)系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機(jī)微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
