python多线程简单实例 多线程队列queue模块

python queue模块的使用方法和注意事项参照 文档https://docs.python.org/zh-cn/3/library/queue.html

一、queue模块包含了四个不同性质的队列类

class queue.Queue(maxsize=0)

Constructor for a FIFO queue. maxsize is an integer that sets the upperbound limit on the number of items that can be placed in the queue. Insertion will block once this size has been reached, until queue items are consumed. If maxsize is less than or equal to zero, the queue size is infinite.

class queue.LifoQueue(maxsize=0)

LIFO 队列构造函数。 maxsize 是个整数，用于设置可以放入队列中的项目数的上限。当达到这个大小的时候，插入操作将阻塞至队列中的项目被消费掉。如果 maxsize 小于等于零，队列尺寸为无限大。

class queue.PriorityQueue(maxsize=0)

优先级队列构造函数。 maxsize 是个整数，用于设置可以放入队列中的项目数的上限。当达到这个大小的时候，插入操作将阻塞至队列中的项目被消费掉。如果 maxsize 小于等于零，队列尺寸为无限大。

最小值先被取出( 最小值条目是由 sorted(list(entries))[0] 返回的条目)。条目的典型模式是一个以下形式的元组： (priority_number, data) 。

如果 data 元素没有可比性，数据将被包装在一个类中，忽略数据值，仅仅比较优先级数字 ：

from dataclasses import dataclass, field
from typing import Any

@dataclass(order=True)
class PrioritizedItem:
    priority: int
    item: Any=field(compare=False)

class queue.SimpleQueue

无界的 FIFO 队列构造函数。简单的队列，缺少任务跟踪等高级功能。

二、Python 3.7 加入了新版功能.

exception queue.Empty

对空的 Queue 对象，调用非阻塞的 get() (or get_nowait()) 时，引发的异常。

q = queue.Queue()
try:
    item = queue.get(block=False) # 同 item = get_nowait()
except queue.Empty:    #当队列设置为不阻塞的时候 队列为空get时将抛出empty异常
    pass

exception queue.Full

对满的 Queue 对象，调用非阻塞的 put() (or put_nowait()) 时，引发的异常。

q = queue.Queue()
try:
    item = queue.put(block=False) # 同 item = put_nowait()
except queue.Full:    #当队列设置为不阻塞的时候 队列满了put将抛出full异常
    pass

三、Queue对象

队列对象 (Queue, LifoQueue, 或者 PriorityQueue) 提供下列描述的公共方法。

Queue.qsize()

返回队列的大致大小。注意，qsize() > 0 不保证后续的 get() 不被阻塞，qsize() < maxsize 也不保证 put() 不被阻塞。

Queue.empty()

如果队列为空，返回 True ，否则返回 False 。如果 empty() 返回 True ，不保证后续调用的 put() 不被阻塞。类似的，如果 empty() 返回 False ，也不保证后续调用的 get() 不被阻塞。

Queue.full()

如果队列是满的返回 True ，否则返回 False 。如果 full() 返回 True 不保证后续调用的 get() 不被阻塞。类似的，如果 full() 返回 False 也不保证后续调用的 put() 不被阻塞。

Queue.put(item, block=True, timeout=None)¶

将 item 放入队列。如果可选参数 block 是 true 并且 timeout 是 None (默认)，则在必要时阻塞至有空闲插槽可用。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间没有可用的空闲插槽，将引发 Full 异常。反之 (block 是 false)，如果空闲插槽立即可用，则把 item 放入队列，否则引发 Full 异常 ( 在这种情况下，timeout 将被忽略)。

Queue.put_nowait(item)

相当于 put(item, False) 。

Queue.get(block=True, timeout=None)

从队列中移除并返回一个项目。如果可选参数 block 是 true 并且 timeout 是 None (默认值)，则在必要时阻塞至项目可得到。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间内项目不能得到，将引发 Empty 异常。反之 (block 是 false) , 如果一个项目立即可得到，则返回一个项目，否则引发 Empty 异常 (这种情况下，timeout 将被忽略)。

POSIX系统3.0之前，以及所有版本的Windows系统中，如果 block 是 true 并且 timeout 是 None ， 这个操作将进入基础锁的不间断等待。这意味着，没有异常能发生，尤其是 SIGINT 将不会触发 KeyboardInterrupt 异常。

Queue.get_nowait()

相当于 get(False) 。

提供了两个方法，用于支持跟踪 排队的任务 是否 被守护的消费者线程 完整的处理。

Queue.task_done()

表示前面排队的任务已经被完成。被队列的消费者线程使用。每个 get() 被用于获取一个任务， 后续调用 task_done() 告诉队列，该任务的处理已经完成。

如果 join() 当前正在阻塞，在所有条目都被处理后，将解除阻塞(意味着每个 put() 进队列的条目的 task_done() 都被收到)。

如果被调用的次数多于放入队列中的项目数量，将引发 ValueError 异常 。

Queue.join()

阻塞至队列中所有的元素都被接收和处理完毕。

当条目添加到队列的时候，未完成任务的计数就会增加。每当消费者线程调用 task_done() 表示这个条目已经被回收，该条目所有工作已经完成，未完成计数就会减少。当未完成计数降到零的时候， join() 阻塞被解除。

四、简单的多线程实例1

(1)创建队列、锁、线程退出标志位

(2)向队列中填充数据

(3)开启多个消费者进行消费 并把消费者线程加入到列表

(4)主线程开启一个循环直到队列为空

(5)更新线程退出标志位

(6)遍历线程列表直到所有线程退出为止

(7)主线程退出

import threading
from threading import Thread
from queue import Queue
import queue 
import time

producer_queue = queue.Queue()
thread_exit_Flag = False
queue_lock = threading.Lock() 

def doTask():
    while not thread_exit_Flag:
        queue_lock.acquire() 
        if producer_queue.empty():
            queue_lock.release()
            time.sleep(1)
            continue
        task = producer_queue.get()
        print("thread %d consumer do task %d" % (threading.get_ident(), task))
        queue_lock.release()    
    print("thread %d exit" % (threading.get_ident()))    


task_sum = 1000
for i in range(task_sum):
    producer_queue.put(i)
num_threads = 10
threads_list = []
for i in range(num_threads):
    # Set up some threads to dotask
    consumer = Thread(target = doTask)
    consumer.start()
    threads_list.append(consumer)

# Wait for the queue to empty 
while not producer_queue.empty(): 
    pass

# Notify threads it's time to exit 
thread_exit_Flag = True

# Wait for all threads to complete 
for t in threads_list: 
    t.join() 
print("exit")

  

五、简单的多线程实例2

封装了queue和thread，在类Myqueue继承了queue模块的类Queue 实现了迭代器和关闭线程的函数

在类Work继承了threading模块Thread类 实现了自己的类初始化和run

 (1)创建队列、创建多个消费者，每个消费者遍历队列取出任务，调用func处理完任务的结果存到done队列

 (2)添加完待处理的任务结束后 向队列中加入退出线程的对象

 (3)执行到task_queue.join()主线程阻塞在这里 直到任务队列计数为0，每次调用队列的put函数队列计数加1，调用task_done计数减1，join判断计数是否为0，阻塞到计数为0为止

 (4)主线程退出

from threading import Thread
from queue import Queue
import threading

class MyQueue(Queue):
    EXIT_TAG = {'exit'}

    def __iter__(self):
        while True :
            item = self.get()
            print("thread %d start to iter get" %(threading.get_ident()), item)
            try:
                if item is self.EXIT_TAG:
                    print("thread %d exit" %(threading.get_ident()))
                    return
                yield item
            finally:
                self.task_done()
                print("thread %d done" %(threading.get_ident()))

    def close(self):
        self.put(self.EXIT_TAG)

class Worker(Thread):
    def __init__(self, func, in_queue, out_queue):
        super().__init__()
        self.func = func
        self.in_queue = in_queue
        self.out_queue = out_queue

    def run(self):
        for item in self.in_queue:
            result = self.func(item)
            self.out_queue.put(result)
            print("thread %d put item %d" %(threading.get_ident(), item))


def test(task):
        return task

if __name__ == '__main__':
    task_queue = MyQueue()
    done_queue = MyQueue()
    num_thread = 4
    task_sum = 10
    for i in range(num_thread):
        thread = Worker(test, task_queue, done_queue)
        thread.start()
    for i in range(task_sum):
        task_queue.put(i)
    for i in range(num_thread):
        task_queue.close()
    task_queue.join()
    print(done_queue.qsize())