在使用多線程的應(yīng)用下，如何保證線程安全，以及線程之間的同步，或者訪問共享變量等問題是十分棘手的問題，也是使用多線程下面臨的問題，如果處理不好，會帶來較嚴(yán)重的后果，使用python多線程中提供Lock Rlock Semaphore Event Condition 用來保證線程之間的同步，后者保證訪問共享變量的互斥問題

Lock & RLock:互斥鎖 用來保證多線程訪問共享變量的問題
Semaphore對象：Lock互斥鎖的加強版，可以被多個線程同時擁有，而Lock只能被某一個線程同時擁有。
Event對象: 它是線程間通信的方式，相當(dāng)于信號，一個線程可以給另外一個線程發(fā)送信號后讓其執(zhí)行操作。
Condition對象：其可以在某些事件觸發(fā)或者達到特定的條件后才處理數(shù)據(jù)

1、Lock(互斥鎖)

請求鎖定 — 進入鎖定池等待 — 獲取鎖 — 已鎖定 — 釋放鎖

Lock（指令鎖）是可用的最低級的同步指令。Lock處于鎖定狀態(tài)時，不被特定的線程擁有。Lock包含兩種狀態(tài)——鎖定和非鎖定，以及兩個基本的方法。

可以認(rèn)為Lock有一個鎖定池，當(dāng)線程請求鎖定時，將線程至于池中，直到獲得鎖定后出池。池中的線程處于狀態(tài)圖中的同步阻塞狀態(tài)。

構(gòu)造方法：
Lock()

實例方法：
acquire([timeout]): 使線程進入同步阻塞狀態(tài)，嘗試獲得鎖定。
release(): 釋放鎖。使用前線程必須已獲得鎖定，否則將拋出異常。

if mutex.acquire():
 counter += 1
 print "I am %s, set counter:%s" % (self.name, counter)
  mutex.release()

2、RLock(可重入鎖)

RLock（可重入鎖）是一個可以被同一個線程請求多次的同步指令。RLock使用了“擁有的線程”和“遞歸等級”的概念，處于鎖定狀態(tài)時，RLock被某個線程擁有。擁有RLock的線程可以再次調(diào)用acquire()，釋放鎖時需要調(diào)用release()相同次數(shù)。

可以認(rèn)為RLock包含一個鎖定池和一個初始值為0的計數(shù)器，每次成功調(diào)用 acquire()/release()，計數(shù)器將+1/-1，為0時鎖處于未鎖定狀態(tài)。

構(gòu)造方法：
RLock()

實例方法：
acquire([timeout])/release(): 跟Lock差不多。

3、Semaphore(共享對象訪問)

咱們再聊聊Semaphore ，說實話Semaphore是我最晚使用的同步鎖，以前類似的實現(xiàn)，是我用Rlock實現(xiàn)的，相對來說有些繞，畢竟Rlock 是需要成對的鎖定和開鎖的》。。。

Semaphore管理一個內(nèi)置的計數(shù)器，
每當(dāng)調(diào)用acquire()時內(nèi)置計數(shù)器-1；
調(diào)用release() 時內(nèi)置計數(shù)器+1；
計數(shù)器不能小于0；當(dāng)計數(shù)器為0時，acquire()將阻塞線程直到其他線程調(diào)用release()。

直接上代碼，我們把semaphore控制為3，也就是說，同時有3個線程可以用這個鎖，剩下的線程也之只能是阻塞等待了…

#coding:utf-8
#blog xiaorui.cc
import time
import threading

semaphore = threading.Semaphore(3)

def func():
 if semaphore.acquire():
  for i in range(3):
   time.sleep(1)
   print (threading.currentThread().getName() + '獲取鎖')
  semaphore.release()
  print (threading.currentThread().getName() + ' 釋放鎖')


for i in range(5):
 t1 = threading.Thread(target=func)
 t1.start()

4、Event(線程間通信)

Event內(nèi)部包含了一個標(biāo)志位，初始的時候為false。
可以使用使用set()來將其設(shè)置為true；
或者使用clear()將其從新設(shè)置為false；
可以使用is_set()來檢查標(biāo)志位的狀態(tài)；

另一個最重要的函數(shù)就是wait(timeout=None)，用來阻塞當(dāng)前線程，直到event的內(nèi)部標(biāo)志位被設(shè)置為true或者timeout超時。如果內(nèi)部標(biāo)志位為true則wait()函數(shù)理解返回。

import threading
import time

class MyThread(threading.Thread):
 def __init__(self, signal):
  threading.Thread.__init__(self)
  self.singal = signal

 def run(self):
  print "I am %s,I will sleep ..."%self.name
  self.singal.wait()
  print "I am %s, I awake..." %self.name

if __name__ == "__main__":
 singal = threading.Event()
 for t in range(0, 3):
  thread = MyThread(singal)
  thread.start()

 print "main thread sleep 3 seconds... "
 time.sleep(3)

 singal.set()

5、Condition(線程同步)

可以把Condition理解為一把高級的瑣，它提供了比Lock, RLock更高級的功能，允許我們能夠控制復(fù)雜的線程同步問題。threadiong.Condition在內(nèi)部維護一個瑣對象（默認(rèn)是RLock），可以在創(chuàng)建Condigtion對象的時候把瑣對象作為參數(shù)傳入。Condition也提供了acquire, release方法，其含義與瑣的acquire, release方法一致，其實它只是簡單的調(diào)用內(nèi)部瑣對象的對應(yīng)的方法而已。Condition還提供了如下方法(特別要注意：這些方法只有在占用瑣(acquire)之后才能調(diào)用，否則將會報RuntimeError異常。)：

Condition.wait([timeout]):

wait方法釋放內(nèi)部所占用的瑣，同時線程被掛起，直至接收到通知被喚醒或超時（如果提供了timeout參數(shù)的話）。當(dāng)線程被喚醒并重新占有瑣的時候，程序才會繼續(xù)執(zhí)行下去。

Condition.notify():

喚醒一個掛起的線程（如果存在掛起的線程）。注意：notify()方法不會釋放所占用的瑣。

Condition.notify_all()
Condition.notifyAll()

喚醒所有掛起的線程（如果存在掛起的線程）。注意：這些方法不會釋放所占用的瑣。

對于Condition有個例子，大家可以觀摩下。

from threading import Thread, Condition
import time
import random

queue = []
MAX_NUM = 10
condition = Condition()

class ProducerThread(Thread):
 def run(self):
  nums = range(5)
  global queue
  while True:
   condition.acquire()
   if len(queue) == MAX_NUM:
    print "Queue full, producer is waiting"
    condition.wait()
    print "Space in queue, Consumer notified the producer"
   num = random.choice(nums)
   queue.append(num)
   print "Produced", num
   condition.notify()
   condition.release()
   time.sleep(random.random())


class ConsumerThread(Thread):
 def run(self):
  global queue
  while True:
   condition.acquire()
   if not queue:
    print "Nothing in queue, consumer is waiting"
    condition.wait()
    print "Producer added something to queue and notified the consumer"
   num = queue.pop(0)
   print "Consumed", num
   condition.notify()
   condition.release()
   time.sleep(random.random())


ProducerThread().start()
ConsumerThread().start()

以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。

最新評論