python queue模块

1 模块介绍

Python的Queue模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列PriorityQueue。这些队列都实现了锁原语，能够在多线程中直接使用。可以使用队列来实现线程间的同步。

2 队列

2.1 queue.Queue(maxsize=0)

先进先出(First In First Out: FIFO)队列，最早进入队列的数据拥有出队列的优先权。

入参 maxsize 是一个整数，用于设置队列的最大长度。一旦队列达到上限，插入数据将会被阻塞，直到有数据出队列之后才可以继续插入。如果 maxsize 设置为小于或等于零，则队列的长度没有限制。

import queue

q = queue.Queue()  #创建队列
for i in range(3):
    q.put(i)  # 依次将0 1 2 插入队列
    
for i in range(3):
    print(q.get())  #依次从队列中取出插入的元素，数据元素输出顺序为0、1、2

2.2 queue.LifoQueue(maxsize=0)

后进先出(Last In First Out: LIFO)队列，最后进入队列的数据拥有出队列的优先权，就像栈一样。入参 maxsize 与先进先出队列的定义一样。

import queue

lq = queue.LifoQueue()  #创建队列
for i in range(3):
    lq.put(i)  # 依次将0 1 2 插入队列
    
for i in range(3):
    print(lq.get())  #依次从队列中取出插入的元素，数据元素输出顺序为2、1、0

2.3 PriorityQueue(maxsize=0)

优先级队列，比较队列中每个数据的大小，值最小的数据拥有出队列的优先权。数据一般以元组的形式插入，典型形式为(priority_number, data)。如果队列中的数据没有可比性，那么数据将被包装在一个类中，忽略数据值，仅仅比较优先级数字。

入参 maxsize 与先进先出队列的定义一样。

import queue

pq = queue.PriorityQueue()  #创建队列

data1 = (1, 'python')
data2 = (2, 'java')
data3 = (3, 'php')

data_list = [data3, data1, data2]
for data in data_list:
    pq.put(data) # 依次将data3、data1、data2插入队列中

for i in range(3):
    print(pq.get())  #依次从队列中取出插入的元素，数据元素输出顺序为data1、data2、data3

3 队列常用方法

以 queue.Queue队列为例：

方法	含义
Queue.put(item)	写入队列，timeout等待时间
Queue.get([block[, timeout]])	获取队列，timeout等待时间
Queue.get_nowait()	相当于Queue.get(False)，非阻塞方法
Queue.qsize()	返回队列的大小
Queue.empty()	如果队列为空，返回True,反之False
Queue.full()	如果队列满了，返回True,反之False，Queue.full 与 maxsize 大小对应
Queue.task_done()	在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号。每个get()调用得到一个任务，接下来task_done()调用告诉队列该任务已经处理完毕。
Queue.join()	实际上意味着等到队列为空，再执行别的操作

3.1 Queue.qsize()

返回队列中数据元素的个数

import queue

q = queue.Queue()  #创建队列

for i in range(5):
    q.put(5)

print("队列大小为：{}".format(q.qsize()))

3.2 Queue.empty()

如果队列为空，返回 True，否则返回 False

import queue

q = queue.Queue()  #创建队列

print("队列为空：{}".format(q.empty()))
q.put('python') # 向队列中插入一个元素
print("队列为空：{}".format(q.empty()))

3.3 Queue.full()

如果队列中元素个数达到上限，返回 True，否则返回 False

import queue

q = queue.Queue(3)  #创建队列，设定队列大小为3

for i in range(2):
    q.put(i)  # 向队列中插入2个元素
    
print("队列达到上限：{}".format(q.full()))
q.put('python') # 向队列中再插入一个元素
print("队列达到上限：{}".format(q.full()))

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

• item，放入队列中的数据元素。
• block，当队列中元素个数达到上限继续往里放数据时：如果 block=False，直接引发 queue.Full 异常；如果 block=True，且 timeout=None，则一直等待直到有数据出队列后可以放入数据；如果block=True，且 timeout=N，N 为某一正整数时，则等待 N 秒，如果队列中还没有位置放入数据就引发 queue.Full 异常。
• timeout，设置超时时间。

import queue

q = queue.Queue(2)  #创建队列，设定队列大小为2

for i in range(2):
    q.put(i)
    
print("队列达到上限：{}".format(q.full()))
q.put('python',block=True, timeout=5) # 向队列中再插入一个元素,等待5秒后，会抛出 queue.Full 异常

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

从队列中取出数据并返回该数据内容

• block，当队列中没有数据元素继续取数据时：如果 block=False，直接引发 queue.Empty 异常；如果 block=True，且 timeout=None，则一直等待直到有数据入队列后可以取出数据；如果 block=True，且 timeout=N，N 为某一正整数时，则等待 N 秒，如果队列中还没有数据放入的话就引发 queue.Empty 异常。
• timeout，设置超时时间

import queue

q = queue.Queue(2)  #创建队列，设定队列大小为2

q.get(block = True, timeout = 5) # 队列为空，往队列中取数据时，等待5秒后会引发 queue.Empty 异常

3.5 Queue.put_nowait(item)

相当于 Queue.put(item, block=False)，当队列中元素个数达到上限继续往里放数据时直接引发 queue.Full 异常

import queue

q = queue.Queue(2)  #创建队列，设定队列大小为2

for i in range(2):
    q.put(i)
    
print("队列达到上限：{}".format(q.full()))
q.put_nowait('python') # 向队列中再插入一个元素,会立即抛出 queue.Full 异常

3.6 Queue.get_nowait()

相当于 Queue.get(block=False)block，当队列中没有数据元素继续取数据时直接引发 queue.Empty 异常

import queue

q = queue.Queue(2)  #创建队列，设定队列大小为2

q.get_nowait() #队列为空，往队列中取数据时直接引发 queue.Empty 异常

3.7 Queue.task_done() 和 Queue.join()

• task_done: 表示队列内的数据元素已经被取出，即每个 get 用于获取一个数据元素， 后续调用 task_done 告诉队列，该数据的处理已经完成。如果被调用的次数多于放入队列中的元素个数，将引发 ValueError 异常
• join: join，一直阻塞直到队列中的所有数据元素都被取出和执行，只要有元素添加到 queue 中就会增加。当未完成任务的计数等于0，join 就不会阻塞

import queue

q = queue.Queue()
q.put('python')
q.put('java')
q.put('php')
for i in range(3):
    print(q.get())
    q.task_done()  # 如果不执行 task_done，join 会一直处于阻塞状态，等待 task_done 告知它数据的处理已经完成

q.join()
print("处理结束")

4 生产者消费者模式

生产者模块儿负责产生数据，放入缓冲区，这些数据由另一个消费者模块儿来从缓冲区取出并进行消费者相应的处理。该模式的优点在于：

• 解耦：缓冲区的存在可以让生产者和消费者降低互相之间的依赖性，一个模块儿代码变化，不会直接影响另一个模块儿
• 并发：由于缓冲区，生产者和消费者不是直接调用，而是两个独立的并发主体，生产者产生数据之后把它放入缓冲区，就继续生产数据，不依赖消费者的处理速度

在Python中，队列是最常用的线程间的通信方法，因为它是线程安全的，自带锁。而Condition等需要额外加锁的代码操作，在编程对死锁现象要很小心，Queue就不用担心这个问题，采用 task_done 和 join 确保处理信息在多个线程间安全交换，生产者生产的数据能够全部被消费者消费掉。

示例：

import threading
import time
from queue import Queue,Empty

produce_flag = False


# 生产者
class Producer(threading.Thread):
    def __init__(self, url_queue):
        super(Producer, self).__init__()
        self.url_queue = url_queue

    def run(self):
        print("---开始生成数据---")
        try:
            for i in range(5):
                time.sleep(0.5)
                url = "www.test.com/{}".format(i)
                self.url_queue.put(url) # 将数据存入队列
                print("--- 将列表页存入队列 - {}\n".format(url))
        finally:
            global produce_flag
            produce_flag = True  # 生产完成后，将生产者标识改为 True


class Consumer(threading.Thread):
    def __init__(self, url_queue):
        super(Consumer, self).__init__()
        self.url_queue = url_queue

    def run(self):
        print("### 拿出已经生产好的数据 ###")
        while True:
            try:
                url = self.url_queue.get(timeout=3)
                time.sleep(0.5)
                print("### 已经获取到页面 - {}\n".format(url))
                self.url_queue.task_done()
            except Empty:
                global produce_flag
                if produce_flag:
                    break


if __name__ == '__main__':
    url_queue = Queue(10)
    producer = Producer(url_queue)
    consumer = Consumer(url_queue)
    time_start = time.time()
    producer.start()
    consumer.start()
    url_queue.join()   # 阻塞，直到生产者生产的数据全都被消费掉
    producer.join()    # 等待生产者线程结束
    consumer.join()    # 等待消费者线程结束
    time_span = time.time() - time_start
    print(time_span)