這篇文章主要介紹“python中的多線程鎖lock=threading.Lock()如何使用”，在日常操作中，相信很多人在python中的多線程鎖lock=threading.Lock()如何使用問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”python中的多線程鎖lock=threading.Lock()如何使用”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！
多線程任務是同時執行的，如果我們需要先執行線程a，再執行線程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()運行結果：可看到，線程a和b是同時執行的
a1
b1
a2b2a3
b3Process 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()運行結果：可看到，線程a先執行完，再執行線程b
a1
a2
a3
b1
b2
b3Process finished with exit code 0
mutex = threading.Lock() #鎖的使用 #創建鎖 mutex = threading.Lock() #鎖定 mutex.acquire([timeout]) #釋放 mutex.release()
好幾個人問我給資源加鎖是怎么回事，其實并不是給資源加鎖, 而是用鎖去鎖定資源，你可以定義多個鎖, 像下面的代碼, 當你需要獨占某一資源時，任何一個鎖都可以鎖這個資源
就好比你用不同的鎖都可以把相同的一個門鎖住是一個道理
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()
最普通的一個多線程小例子。我一筆帶過地講一講，我創建了一個繼承Thread類的子類MyThread，作為我們的線程啟動類。按照規定，重寫Thread的run方法，我們的線程啟動起來后會自動調用該方法。于是我首先創建了10個線程，并將其加入列表中。再使用一個for循環，開啟每個線程。在使用一個for循環，調用join方法等待所有線程結束才退出主線程。
這段代碼看似簡單，但實際上隱藏著一個很大的問題，只是在這里沒有體現出來。你真的以為我創建了10個線程，并按順序調用了這10個線程，每個線程為n增加了1.實際上，有可能是A線程執行了n++，再C線程執行了n++，再B線程執行n++。
這里涉及到一個“鎖”的問題，如果有多個線程同時操作一個對象，如果沒有很好地保護該對象，會造成程序結果的不可預期（比如我們在每個線程的run方法中加入一個time.sleep(1)，并同時輸出線程名稱，則我們會發現，輸出會亂七八糟。因為可能我們的一個print語句只打印出一半的字符，這個線程就被暫停，執行另一個去了，所以我們看到的結果很亂），這種現象叫做“線程不安全”
于是，Threading模塊為我們提供了一個類，Threading.Lock，鎖。我們創建一個該類對象，在線程函數執行前，“搶占”該鎖，執行完成后，“釋放”該鎖，則我們確保了每次只有一個線程占有該鎖。這時候對一個公共的對象進行操作，則不會發生線程不安全的現象了。
于是，我們把代碼更改如下：
# 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
我們看到，我們先建立了一個threading.Lock類對象lock,在run方法里，我們使用lock.acquire()獲得了這個鎖。此時，其他的線程就無法再獲得該鎖了，他們就會阻塞在“if lock.acquire()”這里，直到鎖被另一個線程釋放：lock.release()。
所以，if語句中的內容就是一塊完整的代碼，不會再存在執行了一半就暫停去執行別的線程的情況。所以最后結果是整齊的。
就如同在java中，我們使用synchronized關鍵字修飾一個方法，目的一樣，讓某段代碼被一個線程執行時，不會打斷跳到另一個線程中。
這是多線程占用一個公共對象時候的情況。如果多個線程要調用多個現象，而A線程調用A鎖占用了A對象，B線程調用了B鎖占用了B對象,A線程不能調用B對象，B線程不能調用A對象，于是一直等待。這就造成了線程“死鎖”。
Threading模塊中，也有一個類，RLock，稱之為可重入鎖。該鎖對象內部維護著一個Lock和一個counter對象。counter對象記錄了acquire的次數，使得資源可以被多次require。最后，當所有RLock被release后，其他線程才能獲取資源。在同一個線程中，RLock.acquire可以被多次調用，利用該特性，可以解決部分死鎖問題。
到此，關于“python中的多線程鎖lock=threading.Lock()如何使用”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
