多線程同步和優先級隊列（Queue）

線程同步

若是多個線程共同對某個數據修改，則可能出現不可預料的結果，爲了保證數據的正確性，須要對多個線程進行同步。

使用 Thread 對象的 Lock 和 Rlock 能夠實現簡單的線程同步，這兩個對象都有 acquire 方法和 release 方法，對於那些須要每次只容許一個線程操做的數據，能夠將其操做放到 acquire 和 release 方法之間。以下：

多線程的優點在於能夠同時運行多個任務（至少感受起來是這樣）。可是當線程須要共享數據時，可能存在數據不一樣步的問題。

考慮這樣一種狀況：一個列表裏全部元素都是0，線程"set"從後向前把全部元素改爲1，而線程"print"負責從前日後讀取列表並打印。

那麼，可能線程"set"開始改的時候，線程"print"便來打印列表了，輸出就成了一半0一半1，這就是數據的不一樣步。爲了不這種狀況，引入了鎖的概念。

鎖有兩種狀態——鎖定和未鎖定。每當一個線程好比"set"要訪問共享數據時，必須先得到鎖定；若是已經有別的線程好比"print"得到鎖定了，那麼就讓線程"set"暫停，也就是同步阻塞；等到線程"print"訪問完畢，釋放鎖之後，再讓線程"set"繼續。

通過這樣的處理，打印列表時要麼所有輸出0，要麼所有輸出1，不會再出現一半0一半1的尷尬場面。

實例：

#!/usr/bin/python3 import time 
import threading exitFlag = 0 class myThread(threading.Thread): def __init__(self, threadID, name, counter): threading.Thread.__init__(self) self.threadId=threadID self.name=name self.counter=counter def run(self): print("開始線程：" + self.name) # 獲取鎖，用於線程同步
 threadLock.acquire() print_time(self.name, self.counter, 5) print ("退出線程：" + self.name) # 釋放鎖
 threadLock.release() #輸出線程
def print_time(threadName, delay, counter): while counter: if exitFlag: threadName.exit() time.sleep(delay) print ("%s: %s" % (threadName, time.ctime(time.time()))) counter -= 1
# 建立新線程
thread1 = myThread(1, "Thread-1", 1) thread2 = myThread(2, "Thread-2", 2) threadLock = threading.Lock() # 添加線程到線程列表
threads=[] threads.append(thread1) threads.append(thread2) # 開啓新線程
t0=time.clock() print("開始計算時間",t0) for t in threads: t.start() # 等待全部線程完成
for t in threads: t.join() print ("退出主線程") print(" 結束計算實",time.clock()-t0)

線程優先級隊列（ Queue）

Python 的 Queue 模塊中提供了同步的、線程安全的隊列類，包括FIFO（先入先出)隊列Queue，LIFO（後入先出）隊列LifoQueue，和優先級隊列 PriorityQueue。

這些隊列都實現了鎖原語，可以在多線程中直接使用，可使用隊列來實現線程間的同步。

Queue 模塊中的經常使用方法:

 

• Queue.qsize() 返回隊列的大小
• Queue.empty() 若是隊列爲空，返回True,反之False
• Queue.full() 若是隊列滿了，返回True,反之False
• Queue.full 與 maxsize 大小對應
• Queue.get([block[, timeout]])獲取隊列，timeout等待時間
• Queue.get_nowait() 至關Queue.get(False)
• Queue.put(item) 寫入隊列，timeout等待時間
• Queue.put_nowait(item) 至關Queue.put(item, False)
• Queue.task_done() 在完成一項工做以後，Queue.task_done()函數向任務已經完成的隊列發送一個信號
• Queue.join() 實際上意味着等到隊列爲空，再執行別的操做

實例:

 

#!/usr/bin/python3

import queue import threading import time exitFlag = 0 #自定義多線程類
class myThread (threading.Thread): def __init__(self, threadID, name, q): threading.Thread.__init__(self) self.threadID = threadID self.name = name self.q = q def run(self): print ("開啓線程：" + self.name) process_data(self.name, self.q) print ("退出線程：" + self.name) #公共方法
def process_data(threadName, q): while not exitFlag: queueLock.acquire() if not workQueue.empty(): data = q.get() queueLock.release() print ("%s processing %s" % (threadName, data)) else: queueLock.release() time.sleep(1) #變量定義區 #線程名列表
threadList = ["Thread-1", "Thread-2", "Thread-3"] #執行優先級標記列表
nameList = ["One", "Two", "Three", "Four", "Five"] #線程同步鎖
queueLock = threading.Lock() #隊列列表
workQueue = queue.Queue(10) #線程列表
threads = [] threadID = 1

# 建立新線程建立並運行了3個
for tName in threadList: thread = myThread(threadID, tName, workQueue) thread.start() threads.append(thread) threadID += 1

# 填充隊列，填充5個
queueLock.acquire() for word in nameList: workQueue.put(word) queueLock.release() # 等待隊列清空
while not workQueue.empty(): pass

# 通知線程是時候退出
exitFlag = 1

# 等待全部線程完成
for t in threads: t.join() print ("退出主線程")

輸出結果：

問題：3個線程沒錯，可是輸出了5次。爲何會輸出5次？