Python線程專題10:queue、多線程按順序執行

上一篇文章： Python線程專題9:線程終止與掛起、實用工具函數
下一篇文章：敬請期待

queue模塊實現了各類【多生產者-多消費者】隊列。可用於在執行的多個線程之間安全的交換信息。

queue模塊定義了3種不一樣的隊列類。

3種不一樣的隊列類

q=Queue(maxsize):建立一個FIFO(first-in first-out,先進先出)隊列。maxsize是隊列中金額以放入的項的最大數量。
若是省略maxsize參數或將它置爲0，隊列大小將無窮大。

q=LifoQueue(maxsize)：建立一個LIFO（last-in first-out，後進先出）隊列(棧)。

q=PriorityQueue(maxsize)：建立一個優先級隊列，其中項按照優先級從低到高依次排好。
使用這種隊列時，項應該是(priority,data)形式的元組，其中priority時一個標識優先級的數字。

經常使用方法

q.size()：返回隊列的正確大小。由於其餘線程可能正在更新此隊列，因此此方法的返回數字不可靠。

q.empty()：若是隊列爲空，返回True，不然返回False。

q.full()：若是隊列已滿，返回True，不然返回False。

q.put(item,block,timeout)：將item放入隊列。
若是block設爲True（默認值），調用者將被阻塞直到隊列中出現可用的空閒位置爲止。
若是block設爲False，隊列滿時此方法將引起Full異常。

q.put_nowait(item):等價於q.put(item,False)

q.get(block,timeout):從隊列中刪除一項，而後返回這個項。
若是block設爲True（默認值），調用者將阻塞，直到隊列中出現可用的空閒爲止。
若是block設爲False，隊列爲空時將引起Empty異常。
timeout提供可選的超時值，單位爲秒，若是超時，將引起Empty異常。

q.get_nowait()：等價於get(0)

q.task_done():在隊列種數據的消費者用來指示對於項的處理已經結束。若是使用此方法，那麼從隊列中刪除的每一項都應該調用一次。

q.join()：阻塞直到隊列中的全部項均被刪除和處理爲止。一旦爲隊列中的每一項都調用了一次q.task_done()方法，此方法將會直接返回。

實例：

使用 隊列通常能夠簡化多線程的程序。例如，可使用共享隊列將線程鏈接在一塊兒，而沒必要依賴鎖的保護。

在這種模型下，工做者線程通常充當數據的消費者。

from threading import Thread
from queue import Queue
class WorkerThread(Thread):
    def __init__(self,*args,**kwargs):
        Thread.__init__(self,*args,**kwargs)
        self.input_queue=Queue()

    def send(self,item):
        self.input_queue.put(item)
    def close(self):
        self.input_queue.put(None)
        self.input_queue.join()
    def run(self):
        while True:
            item=self.input_queue.get()
            if item is None:
                break
            #實際開發中，此處應該使用有用的工做代替
            print(item)
            self.input_queue.task_done()
        #完成，指示收到和返回哨兵
        self.input_queue.task_done()
        return

if __name__=="__main__":
    w=WorkerThread()
    w.start()
    w.send("Mark")
    w.send("好")
    w.send("TM")
    w.send("帥")
    w.close()

運行結果：

Mark
好
TM
帥

多線程按順序執行

直接看實例吧，控制多線程的執行順序：

代碼：

#控制多線程的執行順序
from threading import Thread,Lock
import time

class Task1(Thread):
    def run(self):
        while True:
             if lock1.acquire():
                print("---Task1---")
                time.sleep(0.5)
                lock2.release()
class Task2(Thread):
    def run(self):
        while True:
             if lock2.acquire():
                print("---Task2---")
                time.sleep(0.5)
                lock3.release()
class Task3(Thread):
    def run(self):
        while True:
             if lock3.acquire():
                print("---Task3---")
                time.sleep(0.5)
                lock1.release()
#建立lock實例1，第一個開始不上鎖
lock1=Lock()
lock2=Lock()
lock2.acquire()
lock3=Lock()
lock3.acquire()

t1=Task1()
t2=Task2()
t3=Task3()

t1.start()
t2.start()
t3.start()

結果：

---Task1---
---Task2---
---Task3---
---Task1---
---Task2---
---Task3---
---Task1---
---Task2---
---Task3---
---Task1---
---Task2---
---Task3---
...