python3?queue多線程通信怎么實現

這篇文章主要介紹了python3 queue多線程通信怎么實現的相關知識，內容詳細易懂，操作簡單快捷，具有一定借鑒價值，相信大家閱讀完這篇python3 queue多線程通信怎么實現文章都會有所收獲，下面我們一起來看看吧。

queue分類

python3 queue分三類：

• 先進先出隊列

• 后進先出的棧

• 優先級隊列

他們的導入方式分別是：

from queue import Queue
from queue import LifoQueue
from queue import

具體方法見下面引用說明。

例子一、生產消費模式

Queue 對象已經包含了必要的鎖，所以你可以通過它在多個線程間多安全地共享數據。 當使用隊列時，協調生產者和消費者的關閉問題可能會有一些麻煩。一個通用的解決方法是在隊列中放置一個特殊的值，當消費者讀到這個值的時候，終止執行。

例如：

from queue import Queue
from threading import Thread
# 用來表示終止的特殊對象
_sentinel = object()
# A thread that produces data
def producer(out_q):
for i in range(10):
print("生產")
out_q.put(i)
out_q.put(_sentinel)
# A thread that consumes data
def consumer(in_q):
while True:
data = in_q.get()
if data is _sentinel:
in_q.put(_sentinel)
break
else:
print("消費", data)
# Create the shared queue and launch both threads
q = Queue()
t1 = Thread(target=consumer, args=(q,))
t2 = Thread(target=producer, args=(q,))
t1.start()
t2.start()

結果：

本例中有一個特殊的地方：消費者在讀到這個特殊值之后立即又把它放回到隊列中，將之傳遞下去。這樣，所有監聽這個隊列的消費者線程就可以全部關閉了。 盡管隊列是最常見的線程間通信機制，但是仍然可以自己通過創建自己的數據結構并添加所需的鎖和同步機制來實現線程間通信。最常見的方法是使用 Condition變量來包裝你的數據結構。下邊這個例子演示了如何創建一個線程安全的優先級隊列。

import heapq
import threading
class PriorityQueue:
def __init__(self):
self._queue = []
self._count = 0
self._cv = threading.Condition()
def put(self, item, priority):
with self._cv:
heapq.heappush(self._queue, (-priority, self._count, item))
self._count += 1
self._cv.notify()
def get(self):
with self._cv:
while len(self._queue) == 0:
self._cv.wait()
return heapq.heappop(self._queue)[-1]

例子二、task_done和join

使用隊列來進行線程間通信是一個單向、不確定的過程。通常情況下，你沒有辦法知道接收數據的線程是什么時候接收到的數據并開始工作的。不過隊列對象提供一些基本完成的特性，比如下邊這個例子中的task_done() 和 join()：

from queue import Queue
from threading import Thread
class Producer(Thread):
def __init__(self, q):
super().__init__()
self.count = 5
self.q = q
def run(self):
while self.count > 0:
print("生產")
if self.count == 1:
self.count -= 1
self.q.put(2)
else:
self.count -= 1
self.q.put(1)
class Consumer(Thread):
def __init__(self, q):
super().__init__()
self.q = q
def run(self):
while True:
print("消費")
data = self.q.get()
if data == 2:
print("stop because data=", data)
# 任務完成，從隊列中清除一個元素
self.q.task_done()
break
else:
print("data is good,data=", data)
# 任務完成，從隊列中清除一個元素
self.q.task_done()
def main():
q = Queue()
p = Producer(q)
c = Consumer(q)
p.setDaemon(True)
c.setDaemon(True)
p.start()
c.start()
# 等待隊列清空
q.join()
print("queue is complete")
if __name__ == '__main__':
main()

結果：

例子三、多線程里用queue

設置倆隊列，一個是要做的任務隊列todo_queue，一個是已經完成的隊列done_queue。
每次執行線程，先從todo_queue隊列里取出一個值，然后執行完，放入done_queue隊列。
如果todo_queue為空，就退出。

import logging
import logging.handlers
import threading
import queue

log_mgr = None
todo_queue = queue.Queue()
done_queue = queue.Queue()
class LogMgr:
def __init__(self, logpath):
self.LOG = logging.getLogger('log')
loghd = logging.handlers.RotatingFileHandler(logpath, "a", 0, 1)
fmt = logging.Formatter("%(asctime)s %(threadName)-10s %(message)s", "%Y-%m-%d %H:%M:%S")
loghd.setFormatter(fmt)
self.LOG.addHandler(loghd)
self.LOG.setLevel(logging.INFO)
def info(self, msg):
if self.LOG is not None:
self.LOG.info(msg)
class Worker(threading.Thread):
global log_mgr
def __init__(self, name):
threading.Thread.__init__(self)
self.name = name
def run(self):
while True:
try:
task = todo_queue.get(False)
if task:
log_mgr.info("HANDLE_TASK: %s" % task)
done_queue.put(1)
except queue.Empty:
break
return
def main():
global log_mgr
log_mgr = LogMgr("mylog")
for i in range(30):
todo_queue.put("data"+str(i))
workers = []
for i in range(3):
w = Worker("worker"+str(i))
workers.append(w)
for i in range(3):
workers[i].start()
for i in range(3):
workers[i].join()
total_num = done_queue.qsize()
log_mgr.info("TOTAL_HANDLE_TASK: %d" % total_num)
exit(0)
if __name__ == '__main__':
main()

輸出日志文件結果：

關于“python3 queue多線程通信怎么實現”這篇文章的內容就介紹到這里，感謝各位的閱讀！相信大家對“python3 queue多線程通信怎么實現”知識都有一定的了解，大家如果還想學習更多知識，歡迎關注億速云行業資訊頻道。