Python線程編程（二）簡單的線程同步

    多個執(zhí)行線程經(jīng)常要共享數(shù)據(jù)，如果僅僅讀取共享數(shù)據(jù)還好，但是如果多個線程要修改共享數(shù)據(jù)的話就可能出現(xiàn)無法預(yù)料的結(jié)果。

    假如兩個線程對象t1和t2都要對數(shù)值num=0進行增1運算，那么t1和t2都各對num修改10次的話，那么num最終的結(jié)果應(yīng)該為20。但是如果當(dāng)t1取得num的值時（假如此時num為0），系統(tǒng)把t1調(diào)度為“sleeping”狀態(tài)，而此時t2轉(zhuǎn)換為“running”狀態(tài)，此時t2獲得的num的值也為0，然后他把num+1的值1賦給num。系統(tǒng)又把t2轉(zhuǎn)化為“sleeping”狀態(tài)，t1為“running”狀態(tài)，由于t1已經(jīng)得到num值為0，所以他也把num+1的值賦給了num為1。本來是2次增1運行，結(jié)果卻是num只增了1次。類似這樣的情況在多線程同時執(zhí)行的時候是有可能發(fā)生的。所以為了防止這類情況的出現(xiàn)就要使用線程同步機制。

    最簡單的同步機制就是“鎖”

    鎖對象用threading.RLock類創(chuàng)建

    mylock = threading.RLock()

    如何使用鎖來同步線程呢？線程可以使用鎖的acquire() （獲得）方法，這樣鎖就進入“locked”狀態(tài)。每次只有一個線程可以獲得鎖。如果當(dāng)另一個線程試圖獲得這個鎖的時候，就會被系統(tǒng)變?yōu)?#8220;blocked”狀態(tài)，直到那個擁有鎖的線程調(diào)用鎖的release() （釋放）方法，這樣鎖就會進入“unlocked”狀態(tài)。“blocked”狀態(tài)的線程就會收到一個通知，并有權(quán)利獲得鎖。如果多個線程處于“blocked”狀態(tài)，所有線程都會先解除“blocked”狀態(tài)，然后系統(tǒng)選擇一個線程來獲得鎖，其他的線程繼續(xù)沉默（“blocked”）。

import threading
mylock = threading.RLock()
class mythread(threading.Thread)
    ...
    def run(self ...):
        ...     #此處 不可以 放置修改共享數(shù)據(jù)的代碼
        mylock.acquire()
        ...     #此處 可以 放置修改共享數(shù)據(jù)的代碼
        mylock.release()
        ...     #此處 不可以 放置修改共享數(shù)據(jù)的代碼

    我們把修改共享數(shù)據(jù)的代碼稱為“臨界區(qū)”，必須將所有“臨界區(qū)”都封閉在同一鎖對象的acquire()和release()方法調(diào)用之間。

    鎖只能提供最基本的同步級別。有時需要更復(fù)雜的線程同步，例如只在發(fā)生某些事件時才訪問一個臨界區(qū)（例如當(dāng)某個數(shù)值改變時）。這就要使用“條件變量”。

    條件變量用threading.Condition類創(chuàng)建

    mycondition = threading.Condition()

    條件變量是如何工作的呢？首先一個線程成功獲得一個條件變量后，調(diào)用此條件變量的wait()方法會導(dǎo)致這個線程釋放這個鎖，并進入“blocked”狀態(tài)，直到另一個線程調(diào)用同一個條件變量的notify()方法來喚醒那個進入“blocked”狀態(tài)的線程。如果調(diào)用這個條件變量的notifyAll()方法的話就會喚醒所有的在等待的線程。

    如果程序或者線程永遠處于“blocked”狀態(tài)的話，就會發(fā)生死鎖。所以如果使用了鎖、條件變量等同步機制的話，一定要注意仔細檢查，防止死鎖情況的發(fā)生。對于可能產(chǎn)生異常的臨界區(qū)要使用異常處理機制中的finally子句來保證釋放鎖。等待一個條件變量的線程必須用notify()方法顯式的喚醒，否則就永遠沉默。保證每一個wait()方法調(diào)用都有一個相對應(yīng)的notify()調(diào)用，當(dāng)然也可以調(diào)用notifyAll()方法以防萬一。

我們經(jīng)常會采用生產(chǎn)者/消費者關(guān)系的兩個線程來處理一個共享緩沖區(qū)的數(shù)據(jù)。例如一個生產(chǎn)者線程接受用戶數(shù)據(jù)放入一個共享緩沖區(qū)里，等待一個 消費者線程對數(shù)據(jù)取出處理。但是如果緩沖區(qū)的太小而生產(chǎn)者和消費者兩個異步線程的速度不同時，容易出現(xiàn)一個線程等待另一個情況。為了盡可能的縮短共享資源 并以相同速度工作的各線程的等待時間，我們可以使用一個“隊列”來提供額外的緩沖區(qū)。

創(chuàng)建一個“隊列”對象

import Queue
myqueue = Queue.Queue(maxsize = 10)

Queue.Queue類即是一個隊列的同步實現(xiàn)。隊列長度可為無限或者有限。可通過Queue的構(gòu)造函數(shù)的可選參數(shù)maxsize來設(shè)定隊列長度。如果maxsize小于1就表示隊列長度無限。

將一個值放入隊列中

myqueue.put(10)

調(diào)用隊列對象的put()方法在隊尾插入一個項目。put()有兩個參數(shù)，第一個item為必需的，為插入項目的值；第二個block為可選參數(shù)，默認為1。如果隊列當(dāng)前為空且block為1，put()方法就使調(diào)用線程暫停,直到空出一個數(shù)據(jù)單元。如果block為0，put方法將引發(fā)Full異常。

將一個值從隊列中取出

myqueue.get()

調(diào)用隊列對象的get()方法從隊頭刪除并返回一個項目?？蛇x參數(shù)為block，默認為1。如果隊列為空且block為1，get()就使調(diào)用線程暫停，直至有項目可用。如果block為0，隊列將引發(fā)Empty異常。

我們用一個例子來展示如何使用Queue

# queue_example.py
from Queue import Queue
import threading
import random
import time

# Producer thread
class Producer(threading.Thread):
def __init__(self, threadname, queue):
threading.Thread.__init__(self, name = threadname)
self.sharedata = queue
def run(self):
for i in range(20):
print self.getName(),'adding',i,'to queue'
self.sharedata.put(i)
time.sleep(random.randrange(10)/10.0)
print self.getName(),'Finished'

# Consumer thread
class Consumer(threading.Thread):
def __init__(self, threadname, queue):
threading.Thread.__init__(self, name = threadname)
self.sharedata = queue
def run(self):
for i in range(20):
print self.getName(),'got a value:',self.sharedata.get()
time.sleep(random.randrange(10)/10.0)
print self.getName(),'Finished'

# Main thread
def main():
queue = Queue()
producer = Producer('Producer', queue)
consumer = Consumer('Consumer', queue)

print 'Starting threads ...'
producer.start()
consumer.start()

producer.join()
consumer.join()

print 'All threads have terminated.'

if __name__ == '__main__':
main()

示例代碼中實現(xiàn)了兩個類：生產(chǎn)者類Producer和消費者類Consumer。前者在一個隨機的時間內(nèi)放入一個值到隊列queue中然后顯示出來，后者在一定隨機的時間內(nèi)從隊列queue中取出一個值并顯示出來。