您的位置:首頁 > 教程 > python > python中的多線程鎖lock=threading.Lock()使用方式

python中的多線程鎖lock=threading.Lock()使用方式

2022-06-18 12:02:06 來源:易采站長站 作者:

python中的多線程鎖lock=threading.Lock()使用方式

目錄
多線程鎖lock=threading.Lock()使用疑問解決方法例子python多線程中鎖的概念鎖可以獨立提取出來概念線程不安全線程鎖

I0A站長之家-易采站長站-Easck.Com

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

I0A站長之家-易采站長站-Easck.Com

疑問

多線程任務是同時執行的,如果我們需要先執行線程a,再執行線程b,需要怎么辦呢?I0A站長之家-易采站長站-Easck.Com

I0A站長之家-易采站長站-Easck.Com

解決方法

使用python的多線程鎖lock。I0A站長之家-易采站長站-Easck.Com

I0A站長之家-易采站長站-Easck.Com

例子

未使用多線程鎖lock:I0A站長之家-易采站長站-Easck.Com

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()

運行結果:可看到,線程a和b是同時執行的I0A站長之家-易采站長站-Easck.Com

a1I0A站長之家-易采站長站-Easck.Com
b1I0A站長之家-易采站長站-Easck.Com
a2b2I0A站長之家-易采站長站-Easck.Com

a3I0A站長之家-易采站長站-Easck.Com
b3I0A站長之家-易采站長站-Easck.Com

Process finished with exit code 0I0A站長之家-易采站長站-Easck.Com

使用多線程鎖lock后:I0A站長之家-易采站長站-Easck.Com

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()

運行結果:可看到,線程a先執行完,再執行線程bI0A站長之家-易采站長站-Easck.Com

a1I0A站長之家-易采站長站-Easck.Com
a2I0A站長之家-易采站長站-Easck.Com
a3I0A站長之家-易采站長站-Easck.Com
b1I0A站長之家-易采站長站-Easck.Com
b2I0A站長之家-易采站長站-Easck.Com
b3I0A站長之家-易采站長站-Easck.Com

Process finished with exit code 0I0A站長之家-易采站長站-Easck.Com

I0A站長之家-易采站長站-Easck.Com

python多線程中鎖的概念

I0A站長之家-易采站長站-Easck.Com

鎖可以獨立提取出來

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

I0A站長之家-易采站長站-Easck.Com

概念

好幾個人問我給資源加鎖是怎么回事,其實并不是給資源加鎖,>

就好比你用不同的鎖都可以把相同的一個門鎖住是一個道理I0A站長之家-易采站長站-Easck.Com

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

I0A站長之家-易采站長站-Easck.Com

線程不安全

最普通的一個多線程小例子。我一筆帶過地講一講,我創建了一個繼承Thread類的子類MyThread,作為我們的線程啟動類。按照規定,重寫Thread的run方法,我們的線程啟動起來后會自動調用該方法。于是我首先創建了10個線程,并將其加入列表中。再使用一個for循環,開啟每個線程。在使用一個for循環,調用join方法等待所有線程結束才退出主線程。I0A站長之家-易采站長站-Easck.Com

這段代碼看似簡單,但實際上隱藏著一個很大的問題,只是在這里沒有體現出來。你真的以為我創建了10個線程,并按順序調用了這10個線程,每個線程為n增加了1.實際上,有可能是A線程執行了n++,再C線程執行了n++,再B線程執行n++。I0A站長之家-易采站長站-Easck.Com

這里涉及到一個“鎖”的問題,如果有多個線程同時操作一個對象,如果沒有很好地保護該對象,會造成程序結果的不可預期(比如我們在每個線程的run方法中加入一個time.sleep(1),并同時輸出線程名稱,則我們會發現,輸出會亂七八糟。因為可能我們的一個print語句只打印出一半的字符,這個線程就被暫停,執行另一個去了,所以我們看到的結果很亂),這種現象叫做“線程不安全”I0A站長之家-易采站長站-Easck.Com

I0A站長之家-易采站長站-Easck.Com

線程鎖

于是,Threading模塊為我們提供了一個類,Threading.Lock,鎖。我們創建一個該類對象,在線程函數執行前,“搶占”該鎖,執行完成后,“釋放”該鎖,則我們確保了每次只有一個線程占有該鎖。這時候對一個公共的對象進行操作,則不會發生線程不安全的現象了。I0A站長之家-易采站長站-Easck.Com

于是,我們把代碼更改如下:I0A站長之家-易采站長站-Easck.Com

# 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-2I0A站長之家-易采站長站-Easck.Com
2 Thread-3I0A站長之家-易采站長站-Easck.Com
3 Thread-4I0A站長之家-易采站長站-Easck.Com
4 Thread-6I0A站長之家-易采站長站-Easck.Com
5 Thread-7I0A站長之家-易采站長站-Easck.Com
6 Thread-1I0A站長之家-易采站長站-Easck.Com
7 Thread-8I0A站長之家-易采站長站-Easck.Com
8 Thread-9I0A站長之家-易采站長站-Easck.Com
9 Thread-5I0A站長之家-易采站長站-Easck.Com
 I0A站長之家-易采站長站-Easck.Com
Process finished with exit code 0I0A站長之家-易采站長站-Easck.Com

我們看到,我們先建立了一個threading.Lock類對象lock,在run方法里,我們使用lock.acquire()獲得了這個鎖。此時,其他的線程就無法再獲得該鎖了,他們就會阻塞在“if lock.acquire()”這里,直到鎖被另一個線程釋放:lock.release()。I0A站長之家-易采站長站-Easck.Com

所以,if語句中的內容就是一塊完整的代碼,不會再存在執行了一半就暫停去執行別的線程的情況。所以最后結果是整齊的。I0A站長之家-易采站長站-Easck.Com

就如同在java中,我們使用synchronized關鍵字修飾一個方法,目的一樣,讓某段代碼被一個線程執行時,不會打斷跳到另一個線程中。I0A站長之家-易采站長站-Easck.Com

這是多線程占用一個公共對象時候的情況。如果多個線程要調用多個現象,而A線程調用A鎖占用了A對象,B線程調用了B鎖占用了B對象,A線程不能調用B對象,B線程不能調用A對象,于是一直等待。這就造成了線程“死鎖”。I0A站長之家-易采站長站-Easck.Com

Threading模塊中,也有一個類,RLock,稱之為可重入鎖。該鎖對象內部維護著一個Lock和一個counter對象。counter對象記錄了acquire的次數,使得資源可以被多次require。最后,當所有RLock被release后,其他線程才能獲取資源。在同一個線程中,RLock.acquire可以被多次調用,利用該特性,可以解決部分死鎖問題。I0A站長之家-易采站長站-Easck.Com

以上為個人經驗,希望能給大家一個參考,也希望大家多多支持易采站長站。I0A站長之家-易采站長站-Easck.Com

如有侵權,請聯系QQ:279390809 電話:15144810328

相關文章

色七七影院_香港三级台湾三级在线播放_男人放进女人阳道猛进猛出