Python queue 模块

在 Python 中，queue 模块提供了一个线程安全的队列实现，用于在多线程编程中安全地传递数据。

队列是一种先进先出（FIFO）的数据结构，queue 模块提供了多种队列类型，包括 Queue、LifoQueue 和 PriorityQueue，以满足不同的需求。

队列类型

1. Queue

Queue 是 queue 模块中最常用的队列类型，它实现了标准的先进先出（FIFO）队列。以下是 Queue 的基本用法：

实例

import queue

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

# 向队列中添加元素
q.put(1)
q.put(2)
q.put(3)

# 从队列中获取元素
print(q.get())  # 输出: 1
print(q.get())  # 输出: 2
print(q.get())  # 输出: 3

2. LifoQueue

LifoQueue 是一种后进先出（LIFO）的队列，类似于栈。以下是 LifoQueue 的基本用法：

实例

import queue

# 创建一个 LIFO 队列
q = queue.LifoQueue()

# 向队列中添加元素
q.put(1)
q.put(2)
q.put(3)

# 从队列中获取元素
print(q.get())  # 输出: 3
print(q.get())  # 输出: 2
print(q.get())  # 输出: 1

3. PriorityQueue

PriorityQueue 是一种优先级队列，元素按照优先级顺序被取出。以下是 PriorityQueue 的基本用法：

实例

import queue

# 创建一个优先级队列
q = queue.PriorityQueue()

# 向队列中添加元素，元素为元组 (优先级, 数据)
q.put((3, 'Low priority'))
q.put((1, 'High priority'))
q.put((2, 'Medium priority'))

# 从队列中获取元素
print(q.get())  # 输出: (1, 'High priority')
print(q.get())  # 输出: (2, 'Medium priority')
print(q.get())  # 输出: (3, 'Low priority')

常用方法

1. put(item, block=True, timeout=None)

将 item 放入队列。如果 block 为 True 且队列已满，则等待 timeout 秒，直到队列有空闲空间。如果 timeout 为 None，则无限等待。

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

从队列中获取并移除一个元素。如果 block 为 True 且队列为空，则等待 timeout 秒，直到队列中有元素。如果 timeout 为 None，则无限等待。

3. qsize()

返回队列中的元素数量。

4. empty()

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

5. full()

如果队列已满，返回 True，否则返回 False。

线程安全

queue 模块的所有队列类型都是线程安全的，这意味着多个线程可以安全地同时操作同一个队列，而不需要额外的同步机制。这使得 queue 模块成为多线程编程中传递数据的理想选择。

示例：多线程队列

以下是一个使用 Queue 在多线程之间传递数据的示例：

实例

import queue
import threading
import time

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

# 生产者线程
def producer():
    for i in range(5):
        print(f'生产 {i}')
        q.put(i)
        time.sleep(1)

# 消费者线程
def consumer():
    while True:
        item = q.get()
        if item is None:
            break
        print(f'消费 {item}')
        q.task_done()

# 启动生产者线程
producer_thread = threading.Thread(target=producer)
producer_thread.start()

# 启动消费者线程
consumer_thread = threading.Thread(target=consumer)
consumer_thread.start()

# 等待生产者线程完成
producer_thread.join()

# 等待队列中的所有任务完成
q.join()

# 发送结束信号
q.put(None)
consumer_thread.join()

常用的属性和方法

以下是 Python queue 模块（线程安全队列）的常用类、方法及属性的表格说明，包含功能描述和示例：

queue 模块核心类

类说明适用场景
queue.Queue先进先出（FIFO）队列通用任务队列
queue.LifoQueue后进先出（LIFO）队列（类似栈）需要后进先出的场景
queue.PriorityQueue优先级队列（最小堆实现）按优先级处理任务
queue.SimpleQueue更简单的FIFO队列（Python 3.7+）不需要高级功能的场景

通用方法（所有队列类都支持）

方法说明示例返回值
put(item)放入元素q.put("task1")None
get()取出并移除元素item = q.get()队列元素
empty()判断队列是否为空if q.empty():True/False
full()判断队列是否已满if q.full():True/False
qsize()返回队列当前大小size = q.qsize()整数
task_done()标记任务完成（用于join()）q.task_done()None
join()阻塞直到所有任务完成q.join()None

阻塞控制参数

参数说明默认值示例
block当队列为空/满时是否阻塞Trueq.get(block=False)
timeout阻塞超时时间（秒）Noneq.put(x, timeout=5)

PriorityQueue 专用用法

元素格式：(priority, data)，优先级越小越先出队

实例

pq = queue.PriorityQueue()
pq.put((1, "low"))
pq.put((0, "high"))
print(pq.get()[1])  # 输出: "high"

实例

生产者-消费者模型：

实例

import queue, threading

q = queue.Queue(maxsize=3)  # 容量为3的队列

def producer():
    for i in range(5):
        q.put(f"Task-{i}")
        print(f"Produced: Task-{i}")

def consumer():
    while True:
        item = q.get()
        print(f"Consumed: {item}")
        q.task_done()

threading.Thread(target=producer, daemon=True).start()
threading.Thread(target=consumer, daemon=True).start()
q.join()  # 等待所有任务完成

优先级任务处理：

实例

pq = queue.PriorityQueue()
pq.put((3, "Scan"))
pq.put((1, "Emergency"))
pq.put((2, "Log"))

while not pq.empty():
    print(pq.get()[1])  # 输出顺序: Emergency → Log → Scan

非阻塞获取（避免死锁）：

实例

try:
    item = q.get_nowait()  # 等价于 q.get(block=False)
except queue.Empty:
    print("队列为空")