python如何用queue

Python中的queue模块提供了多种队列实现，这些队列在多线程编程中非常有用，因为它们是线程安全的。主要的队列类型有Queue、LifoQueue、PriorityQueue，它们分别对应FIFO、LIFO和优先级队列。其中，Queue用于先进先出的任务管理，LifoQueue用于后进先出，而PriorityQueue则用于任务的优先级管理。接下来，我们将详细介绍如何在Python中使用这些队列。

一、QUEUE模块概述

Python的queue模块提供了多种队列实现，最常用的包括：

Queue（FIFO队列）：先进先出的队列，适用于大多数任务调度场景。
LifoQueue（LIFO队列）：后进先出的队列，类似于堆栈。
PriorityQueue（优先级队列）：允许按优先级顺序处理任务。

这些队列本质上都是线程安全的，使得它们在多线程环境中非常有用。

二、QUEUE（FIFO队列）

1. 基本用法

Queue是最常用的队列类型，遵循先进先出（FIFO）原则。它适用于大多数需要任务排队的场景。

import queue
创建一个FIFO队列
q = queue.Queue()
插入元素
q.put(10)
q.put(20)
q.put(30)
提取元素
print(q.get())  # 输出: 10
print(q.get())  # 输出: 20

2. 阻塞与超时

Queue支持阻塞操作，这意味着如果队列为空，get()方法会阻塞线程，直到有数据可用。可以使用超时参数来避免永久阻塞。

# 阻塞提取，设置超时时间
try:
    print(q.get(timeout=1))  # 若1秒内无数据可提取，将抛出queue.Empty异常
except queue.Empty:
    print("队列为空")

3. 队列的最大长度

可以在创建队列时设定最大长度，以避免无限制地占用内存。

# 创建一个最大长度为2的队列
q = queue.Queue(maxsize=2)
q.put(10)
q.put(20)
try:
    q.put(30, timeout=1)  # 若队列满，等待1秒后抛出queue.Full异常
except queue.Full:
    print("队列已满")

三、LIFOQUEUE（LIFO队列）

1. 基本用法

LifoQueue类似于堆栈，遵循后进先出（LIFO）原则。

import queue
创建一个LIFO队列
lq = queue.LifoQueue()
插入元素
lq.put(10)
lq.put(20)
lq.put(30)
提取元素
print(lq.get())  # 输出: 30
print(lq.get())  # 输出: 20

2. 使用场景

LifoQueue适用于需要后进先出顺序处理的场景，例如深度优先搜索算法中的节点处理。

四、PRIORITYQUEUE（优先级队列）

1. 基本用法

PriorityQueue允许按照优先级处理任务，优先级越小的任务越先被处理。

import queue
创建一个优先级队列
pq = queue.PriorityQueue()
插入元素（优先级, 数据）
pq.put((2, "任务2"))
pq.put((1, "任务1"))
pq.put((3, "任务3"))
提取元素
print(pq.get()[1])  # 输出: 任务1
print(pq.get()[1])  # 输出: 任务2

2. 自定义优先级

可以使用元组的方式来定义优先级，元组的第一个元素即为优先级。

# 自定义优先级
pq.put((5, "任务5"))
pq.put((0, "任务0"))
while not pq.empty():
    print(pq.get()[1])  # 按优先级从低到高输出

五、QUEUE模块的应用场景

1. 多线程任务调度

在多线程环境中，queue模块非常适合用于任务调度。生产者线程可以将任务放入队列，而消费者线程则从队列中提取任务进行处理。

import queue
import threading
import time
def producer(q):
    for i in range(5):
        print(f"生产者添加任务{i}")
        q.put(i)
        time.sleep(1)
def consumer(q):
    while True:
        task = q.get()
        print(f"消费者处理任务{task}")
        time.sleep(2)
        q.task_done()
task_queue = queue.Queue()
threading.Thread(target=producer, args=(task_queue,)).start()
threading.Thread(target=consumer, args=(task_queue,), daemon=True).start()
等待所有任务完成
task_queue.join()

2. 任务池管理

队列可以用于管理任务池，特别是需要限制同时处理的任务数量时。

import queue
import threading
def worker(task_queue):
    while not task_queue.empty():
        task = task_queue.get()
        print(f"处理任务 {task}")
        task_queue.task_done()
tasks = queue.Queue()
for task in range(10):
    tasks.put(task)
threads = []
for _ in range(3):  # 创建3个线程处理任务
    t = threading.Thread(target=worker, args=(tasks,))
    t.start()
    threads.append(t)
for t in threads:
    t.join()