多線程鎖lock=threading.Lock()使用

疑問

多線程任務(wù)是同時(shí)執(zhí)行的，如果我們需要先執(zhí)行線程a，再執(zhí)行線程b，需要怎么辦呢？

解決方法

使用python的多線程鎖lock。

例子

未使用多線程鎖lock：

def a():
? ? for i in range(3):
? ? ? ? print('a%d' % (i + 1))
? ? ? ? time.sleep(1)

def b():
? ? for i in range(3):
? ? ? ? print('b%d' % (i + 1))
? ? ? ? time.sleep(1)

T = threading.Thread(target=a)
T.start()

T = threading.Thread(target=b)
T.start()

運(yùn)行結(jié)果：可看到，線程a和b是同時(shí)執(zhí)行的

a1
b1
a2b2

a3
b3

Process finished with exit code 0

使用多線程鎖lock后：

lock = threading.Lock()

def a():
? ? lock.acquire()
? ? for i in range(3):
? ? ? ? print('a%d' % (i + 1))
? ? ? ? time.sleep(1)
? ? lock.release()

def b():
? ? lock.acquire()
? ? for i in range(3):
? ? ? ? print('b%d' % (i + 1))
? ? ? ? time.sleep(1)
? ? lock.release()

T = threading.Thread(target=a)
T.start()

T = threading.Thread(target=b)
T.start()

運(yùn)行結(jié)果：可看到，線程a先執(zhí)行完，再執(zhí)行線程b

a1
a2
a3
b1
b2
b3

Process finished with exit code 0

python多線程中鎖的概念

鎖可以獨(dú)立提取出來(lái)

mutex = threading.Lock()
#鎖的使用
#創(chuàng)建鎖
mutex = threading.Lock()
#鎖定
mutex.acquire([timeout])
#釋放
mutex.release()

概念

好幾個(gè)人問我給資源加鎖是怎么回事，其實(shí)并不是給資源加鎖, 而是用鎖去鎖定資源，你可以定義多個(gè)鎖, 像下面的代碼, 當(dāng)你需要獨(dú)占某一資源時(shí)，任何一個(gè)鎖都可以鎖這個(gè)資源

就好比你用不同的鎖都可以把相同的一個(gè)門鎖住是一個(gè)道理

import  threading   
import  time   
counter = 0 
counter_lock = threading.Lock() #只是定義一個(gè)鎖,并不是給資源加鎖,你可以定義多個(gè)鎖,像下兩行代碼,當(dāng)你需要占用這個(gè)資源時(shí)，任何一個(gè)鎖都可以鎖這個(gè)資源 
counter_lock2 = threading.Lock()  
counter_lock3 = threading.Lock() 
   
#可以使用上邊三個(gè)鎖的任何一個(gè)來(lái)鎖定資源 
    
class  MyThread(threading.Thread):#使用類定義thread，繼承threading.Thread 
     def  __init__(self,name):   
        threading.Thread.__init__(self)   
        self.name = "Thread-" + str(name) 
     def run(self):   #run函數(shù)必須實(shí)現(xiàn) 
         global counter,counter_lock #多線程是共享資源的，使用全局變量 
         time.sleep(1);   
         if counter_lock.acquire(): #當(dāng)需要獨(dú)占counter資源時(shí)，必須先鎖定，這個(gè)鎖可以是任意的一個(gè)鎖，可以使用上邊定義的3個(gè)鎖中的任意一個(gè) 
            counter += 1    
            print "I am %s, set counter:%s"  % (self.name,counter)   
            counter_lock.release() #使用完counter資源必須要將這個(gè)鎖打開，讓其他線程使用 
               
if  __name__ ==  "__main__":   
    for i in xrange(1,101):   
        my_thread = MyThread(i) 
        my_thread.start()

線程不安全

最普通的一個(gè)多線程小例子。我一筆帶過地講一講，我創(chuàng)建了一個(gè)繼承Thread類的子類MyThread，作為我們的線程啟動(dòng)類。按照規(guī)定，重寫Thread的run方法，我們的線程啟動(dòng)起來(lái)后會(huì)自動(dòng)調(diào)用該方法。于是我首先創(chuàng)建了10個(gè)線程，并將其加入列表中。再使用一個(gè)for循環(huán)，開啟每個(gè)線程。在使用一個(gè)for循環(huán)，調(diào)用join方法等待所有線程結(jié)束才退出主線程。

這段代碼看似簡(jiǎn)單，但實(shí)際上隱藏著一個(gè)很大的問題，只是在這里沒有體現(xiàn)出來(lái)。你真的以為我創(chuàng)建了10個(gè)線程，并按順序調(diào)用了這10個(gè)線程，每個(gè)線程為n增加了1.實(shí)際上，有可能是A線程執(zhí)行了n++，再C線程執(zhí)行了n++，再B線程執(zhí)行n++。

這里涉及到一個(gè)“鎖”的問題，如果有多個(gè)線程同時(shí)操作一個(gè)對(duì)象，如果沒有很好地保護(hù)該對(duì)象，會(huì)造成程序結(jié)果的不可預(yù)期（比如我們?cè)诿總€(gè)線程的run方法中加入一個(gè)time.sleep(1)，并同時(shí)輸出線程名稱，則我們會(huì)發(fā)現(xiàn)，輸出會(huì)亂七八糟。因?yàn)榭赡芪覀兊囊粋€(gè)print語(yǔ)句只打印出一半的字符，這個(gè)線程就被暫停，執(zhí)行另一個(gè)去了，所以我們看到的結(jié)果很亂），這種現(xiàn)象叫做“線程不安全”

線程鎖

于是，Threading模塊為我們提供了一個(gè)類，Threading.Lock，鎖。我們創(chuàng)建一個(gè)該類對(duì)象，在線程函數(shù)執(zhí)行前，“搶占”該鎖，執(zhí)行完成后，“釋放”該鎖，則我們確保了每次只有一個(gè)線程占有該鎖。這時(shí)候?qū)σ粋€(gè)公共的對(duì)象進(jìn)行操作，則不會(huì)發(fā)生線程不安全的現(xiàn)象了。

于是，我們把代碼更改如下：

# coding : uft-8
__author__ = 'Phtih0n'
import threading, time
class MyThread(threading.Thread):
? ? def __init__(self):
? ? ? ? threading.Thread.__init__(self)
? ? def run(self):
? ? ? ? global n, lock
? ? ? ? time.sleep(1)
? ? ? ? if lock.acquire():
? ? ? ? ? ? print n , self.name
? ? ? ? ? ? n += 1
? ? ? ? ? ? lock.release()
if "__main__" == __name__:
? ? n = 1
? ? ThreadList = []
? ? lock = threading.Lock()
? ? for i in range(1, 200):
? ? ? ? t = MyThread()
? ? ? ? ThreadList.append(t)
? ? for t in ThreadList:
? ? ? ? t.start()
? ? for t in ThreadList:
? ? ? ? t.join()

1 Thread-2
2 Thread-3
3 Thread-4
4 Thread-6
5 Thread-7
6 Thread-1
7 Thread-8
8 Thread-9
9 Thread-5
 
Process finished with exit code 0

我們看到，我們先建立了一個(gè)threading.Lock類對(duì)象lock,在run方法里，我們使用lock.acquire()獲得了這個(gè)鎖。此時(shí)，其他的線程就無(wú)法再獲得該鎖了，他們就會(huì)阻塞在“if lock.acquire()”這里，直到鎖被另一個(gè)線程釋放：lock.release()。

所以，if語(yǔ)句中的內(nèi)容就是一塊完整的代碼，不會(huì)再存在執(zhí)行了一半就暫停去執(zhí)行別的線程的情況。所以最后結(jié)果是整齊的。

就如同在java中，我們使用synchronized關(guān)鍵字修飾一個(gè)方法，目的一樣，讓某段代碼被一個(gè)線程執(zhí)行時(shí)，不會(huì)打斷跳到另一個(gè)線程中。

這是多線程占用一個(gè)公共對(duì)象時(shí)候的情況。如果多個(gè)線程要調(diào)用多個(gè)現(xiàn)象，而A線程調(diào)用A鎖占用了A對(duì)象，B線程調(diào)用了B鎖占用了B對(duì)象,A線程不能調(diào)用B對(duì)象，B線程不能調(diào)用A對(duì)象，于是一直等待。這就造成了線程“死鎖”。

Threading模塊中，也有一個(gè)類，RLock，稱之為可重入鎖。該鎖對(duì)象內(nèi)部維護(hù)著一個(gè)Lock和一個(gè)counter對(duì)象。counter對(duì)象記錄了acquire的次數(shù)，使得資源可以被多次require。最后，當(dāng)所有RLock被release后，其他線程才能獲取資源。在同一個(gè)線程中，RLock.acquire可以被多次調(diào)用，利用該特性，可以解決部分死鎖問題。

以上為個(gè)人經(jīng)驗(yàn)，希望能給大家一個(gè)參考，也希望大家多多支持腳本之家。

最新評(píng)論