快捷導(dǎo)航

Python多線程操作之互斥鎖、遞歸鎖、信號(hào)量、事件實(shí)例詳解

更新時(shí)間：2020年03月24日 10:08:34 作者：隨風(fēng)行云

這篇文章主要介紹了Python多線程操作之互斥鎖、遞歸鎖、信號(hào)量、事件,結(jié)合實(shí)例形式詳細(xì)分析了Python多線程操作互斥鎖、遞歸鎖、信號(hào)量、事件相關(guān)概念、原理、用法與操作注意事項(xiàng),需要的朋友可以參考下

本文實(shí)例講述了Python多線程操作之互斥鎖、遞歸鎖、信號(hào)量、事件。分享給大家供大家參考，具體如下：

互斥鎖：

為什么要有互斥鎖：由于多線程是并行的，如果某一線程取出了某一個(gè)數(shù)據(jù)將要進(jìn)行操作，但它還沒有那么快執(zhí)行完操作，這時(shí)候如果另外一個(gè)線程也要操作這個(gè)數(shù)據(jù)，那么這個(gè)數(shù)據(jù)可能會(huì)因?yàn)閮纱尾僮鞫l(fā)生錯(cuò)誤

import time,threading

x=6
def run1():
  print("run1我拿到了數(shù)據(jù):",x)
  print("我現(xiàn)在還不想操作，先睡一下")
  time.sleep(3)
  print("再看一下數(shù)據(jù)，穩(wěn)一穩(wěn)",x)

def run2():
  global x
  print("run2我拿到了數(shù)據(jù):", x)

  x=5
  print(x)

t1=threading.Thread(target=run1)
t2=threading.Thread(target=run2)

t1.start()
t2.start()
t1.join()
t2.join()

而多線程的互斥鎖機(jī)制本質(zhì)上是：申請(qǐng)一個(gè)鎖，A線程拿了鑰匙【acquire】之后，如果B也想拿到鑰匙是不行的，只有等A把鑰匙還回來【release】才行
如何使用互斥鎖：

定義一個(gè)鎖對(duì)象:鎖對(duì)象=threading.Lock()
請(qǐng)求鎖：鎖對(duì)象.acquire()
釋放鎖:鎖對(duì)象.release()

使用互斥鎖來更改上段代碼

import time,threading

x=6
def run1():
  lock.acquire()
  global x
  print("run1我拿到了數(shù)據(jù),x=",x)
  print("我現(xiàn)在還不想操作，先睡一下")
  time.sleep(3)
  print("再看一下數(shù)據(jù)，穩(wěn)一穩(wěn),x=",x)
  x+=1
  print("run1操作完畢:x=",x)
  lock.release()
def run2():
  lock.acquire()
  global x
  print("run2我拿到了數(shù)據(jù):", x)
  x+=1
  print("run2操作完畢:x=",x)
  lock.release()

lock=threading.Lock()#生成一個(gè)鎖對(duì)象
t1=threading.Thread(target=run1)
t2=threading.Thread(target=run2)

t1.start()
t2.start()
start_time=time.time()
t1.join()
t2.join()
print("最終的x=",x)
print(time.time()-start_time)#3.0多說明，由于受到鎖的影響，run2要等待run1釋放lock，所以變成了串行

這種互斥鎖在操作系統(tǒng)中可以稱作“臨界區(qū)”，如果想了解更多：

https://baike.baidu.com/item/%E4%B8%B4%E7%95%8C%E5%8C%BA/8942134?fr=aladdin

遞歸鎖：

為什么要有遞歸鎖：互斥鎖本質(zhì)上是阻止其他線程進(jìn)入，如果有兩個(gè)需要阻止其他線程進(jìn)入的操作【像兩個(gè)人過獨(dú)木橋】，那么需要兩個(gè)鎖，而想要鎖上第二個(gè)如果直接用第一個(gè)鎖的acquire會(huì)失敗，因?yàn)榈谝粋€(gè)鎖還沒release，我們可以選擇再定義一個(gè)互斥鎖對(duì)象來acquire，但這僅僅是兩層的情況下，如果多層的吧，那么就需要定義好幾個(gè)互斥鎖對(duì)象了【而且由于對(duì)象變多，有時(shí)候會(huì)因?yàn)榛ハ嗾{(diào)用鎖而發(fā)生死鎖】。遞歸鎖就是為了處理這種情況，遞歸鎖對(duì)象允許多次acquire和多次release
- 發(fā)生死鎖的情況[A拿到A鎖，想要拿B鎖，B拿著B鎖，想要A鎖]

【以過獨(dú)木橋?yàn)槔浚簶蛑荒苋菀粋€(gè)人通過，A只能看得到北邊橋上有沒有人，看不到南邊橋有沒有人，當(dāng)他看到北邊橋沒人就會(huì)過橋，等到他到橋中間才能看到南邊橋有沒有人，B情況相反：【于是當(dāng)兩個(gè)人一起過橋的時(shí)候就會(huì)發(fā)生死鎖】

import threading,time

"""
A只能看得到北邊橋上有沒有人，看不到南邊橋有沒有人，
當(dāng)他看到北邊橋沒人就會(huì)過橋，等到他到橋中間才能看到南邊橋有沒有人
"""
def A():
  lockNorth.acquire()#拿到北邊橋的鎖
  print("A過橋北")
  time.sleep(3)#過橋中
  lockSorth.acquire()#企圖過到南邊橋，
  print("A過橋南")
  time.sleep(3) # 過橋中
  lockSorth.release()
  lockNorth.release()
  print("A過橋成功")

"""
B只能看得到南邊橋上有沒有人，看不到北邊橋有沒有人，
當(dāng)他看到南邊橋沒人就會(huì)過橋，等到他到橋中間才能看到北邊橋有沒有人
"""
def B():
  lockSorth.acquire() # 企圖過到南邊橋，
  print("B過橋南")
  time.sleep(3) # 過橋中
  lockNorth.acquire() # 拿到北邊橋的鎖
  print("B過橋北")
  time.sleep(3) # 過橋中
  lockNorth.release()
  lockSorth.release()
  print("B過橋成功")


lockNorth=threading.Lock()
lockSorth=threading.Lock()

tA=threading.Thread(target=A)
tB=threading.Thread(target=B)
tA.start()
tB.start()

tA.join()
tB.join()

遞歸鎖的本質(zhì)是：本質(zhì)上還是一個(gè)鎖，但如果在一個(gè)線程里面可以多次acquire。【因?yàn)橹挥幸粋€(gè)鎖，所以不會(huì)發(fā)生互相調(diào)用的死鎖，而因?yàn)榭梢远啻握{(diào)用，所以可以鎖多次】
如何使用遞歸鎖：

定義一個(gè)鎖對(duì)象:遞歸鎖對(duì)象=threading.RLock()
請(qǐng)求鎖：鎖對(duì)象.acquire()
釋放鎖:鎖對(duì)象.release()

使用遞歸鎖來解決上面的死鎖問題：

import threading,time

"""
A只能看得到北邊橋上有沒有人，看不到南邊橋有沒有人，
當(dāng)他看到北邊橋沒人就會(huì)過橋，等到他到橋中間才能看到南邊橋有沒有人
"""
def A():
  lock.acquire()#拿到北邊橋的鎖
  print("A過橋北")
  time.sleep(3)#過橋中
  lock.acquire()#企圖過到南邊橋，
  print("A過橋南")
  time.sleep(3) # 過橋中
  lock.release()
  lock.release()
  print("A過橋成功")

"""
B只能看得到南邊橋上有沒有人，看不到北邊橋有沒有人，
當(dāng)他看到南邊橋沒人就會(huì)過橋，等到他到橋中間才能看到北邊橋有沒有人
"""
def B():
  lock.acquire() # 拿南橋鎖，
  print("B過橋南")
  time.sleep(3) # 過橋中
  lock.acquire() # 企圖拿北橋的鎖
  print("B過橋北")
  time.sleep(3) # 過橋中
  lock.release()
  lock.release()
  print("B過橋成功")


lock=threading.RLock()

tA=threading.Thread(target=A)
tB=threading.Thread(target=B)
tA.start()
tB.start()

tA.join()
tB.join()

【由于本質(zhì)是一把鎖，A拿到鎖后，B要等待】

信號(hào)量：

什么是信號(hào)量：

信號(hào)量可以限制進(jìn)入的線程的數(shù)量。

如何使用信號(hào)量：

創(chuàng)建信號(hào)量對(duì)象：信號(hào)量對(duì)象=threading.BoundedSemaphore(x)，x是限制進(jìn)程的數(shù)量
當(dāng)有進(jìn)程需要進(jìn)入的時(shí)候，調(diào)用acquire()來減少信號(hào)量：信號(hào)量對(duì)象.acquire()
當(dāng)有進(jìn)程離開的時(shí)候，調(diào)用release()來增加信號(hào)量：信號(hào)量對(duì)象.release()

import threading,time


def run():
  s.acquire()
  print("hello")
  time.sleep(1.5)
  s.release()

s=threading.BoundedSemaphore(3)#限制3個(gè)

threading_list=[]
for i in range(12):#創(chuàng)建12個(gè)線程
  obj=threading.Thread(target=run)
  obj.setDaemon(True) # 設(shè)置守護(hù)線程，避免干擾主線程運(yùn)行，并行等待
  obj.start()

for i in range(4):
  print("")#為了把結(jié)果分割，可以清楚看出分為了三組
  time.sleep(1.5)
#結(jié)果分為三組是因?yàn)檫\(yùn)行的太快了，三個(gè)線程裝入的時(shí)間差太小

事件：

什么是事件：當(dāng)發(fā)生線程發(fā)生一件事的時(shí)候如果要提醒另外一個(gè)線程，使用事件。雙方共享該事件對(duì)象【等待的一方會(huì)阻塞而進(jìn)行等待】，當(dāng)一方更改事件對(duì)象的時(shí)候，另外一方也能知道【以讀者-寫者為例：讀者要等寫者告訴他去讀才會(huì)去讀，寫者寫完后要設(shè)置一個(gè)事件，當(dāng)該事件設(shè)置時(shí)，讀者就會(huì)來讀】
如何使用事件：

創(chuàng)建事件對(duì)象：事件對(duì)象=threading.Event()
設(shè)置事件：事件對(duì)象.set() 判斷事件是否set：事件對(duì)象.is_set()，等待事件set：事件對(duì)象.wait()
清除事件：事件對(duì)象.clear()

import threading,time


def read():
  while True:
    if event.is_set():
      print("事件已設(shè)置，我要讀了!!!!")
      time.sleep(1)
    else:#事件未設(shè)置
      print("還沒寫好，我要等咯")
      event.wait()#那么就等著咯
      #如果等到了
      print("終于等到了！那么我又可以讀了")
      time.sleep(1)

def write():
  event.clear()#初始設(shè)空
  while True:
    time.sleep(3)#寫
    event.set()#設(shè)置事件，一旦set,那么讀者wait就有返回了，讀者可以繼續(xù)運(yùn)行了
    print("write:寫好了")
    time.sleep(2)#等人讀
    event.clear()#清除事件


event=threading.Event() #創(chuàng)建事件對(duì)象

t1=threading.Thread(target=write)
t2=threading.Thread(target=read)

t1.start()
t2.start()
t1.join()
t2.join()

"""結(jié)果顯示：讀者確實(shí)一直在等待寫者寫好"""