Python线程优先级队列知识点总结

什么是线程优先级队列？

线程优先级队列是Python标准库中的一个模块，提供了一个可排序的、优先级队列的数据结构。

通常情况下，在多线程编程中，我们需要为线程分配不同的优先级，以确保执行时间更长、执行顺序更重要的任务被先处理。这就是优先级队列的作用。

使用线程优先级队列

在Python中，我们可以使用 queue 模块提供的 PriorityQueue 类创建一个线程优先级队列。

队列中每个元素都是一个元组 (priority_number, data)，其中 priority_number 是任务的优先级，data 是需要处理的数据。

可以使用 put() 方法将元素添加到队列中：

import queue

q = queue.PriorityQueue()

q.put((3, 'Task 1'))
q.put((1, 'Task 2'))
q.put((2, 'Task 3'))

使用 get() 方法可以从队列中取出队首元素：

while not q.empty():
    task = q.get()
    print(task[1])

取出的元素按照优先级从高到低依次输出：

Task 1
Task 3
Task 2

线程优先级队列示例

示例一：模拟抢购场景

假设我们需要编写一个程序来模拟抢购场景。有若干个抢购请求正在等待被处理，我们需要按照请求的提交时间顺序和请求的优先级来处理这些请求。

首先，我们需要定义一个请求类 Request，包含优先级和提交时间两个属性：

class Request:
    def __init__(self, priority: int, submit_time: float):
        self.priority = priority
        self.submit_time = submit_time

    def __lt__(self, other):
        if self.priority != other.priority:
            return self.priority < other.priority
        return self.submit_time < other.submit_time

这里我们定义了一个小于号运算符重载方法 __lt__，以便在比较运算中按照要求排序。

其次，我们需要把请求添加进队列中：

import queue

q = queue.PriorityQueue()

# 添加请求
req1 = Request(2, 2.1)
req2 = Request(3, 3.2)
req3 = Request(1, 0.5)
q.put((req1.priority, req1))
q.put((req2.priority, req2))
q.put((req3.priority, req3))

最后，我们需要按照提交时间顺序和优先级处理请求：

# 处理请求
while not q.empty():
    req = q.get()[1]
    print(f'处理请求，优先级：{req.priority}，提交时间：{req.submit_time}')

输出结果如下：

处理请求，优先级：1，提交时间：0.5
处理请求，优先级：2，提交时间：2.1
处理请求，优先级：3，提交时间：3.2

示例二：模拟生产者-消费者场景

另一个示例是模拟生产者-消费者场景。我们有若干个生产者，每个生产者可以随机生产一定数量的任务，任务的优先级也是随机的。同时，我们有若干个消费者，每个消费者可以从优先级队列中取出并处理一个任务。

首先，我们需要定义一个任务类 Task，包含任务的数据和优先级：

import random

class Task:
    def __init__(self, data: str):
        self.data = data
        self.priority = random.choice(range(10))

接着，我们需要定义一个生产者函数 producer，用于随机生成一定数量的任务，并将任务添加进队列：

import threading
import time

def producer(q: queue.PriorityQueue):
    for i in range(5):
        task_count = random.randint(1, 5)
        for j in range(task_count):
            task = Task(f'Task {i}-{j}')
            q.put((task.priority, task))
            print(f'生产者-{i} 生成任务：{task.data}，优先级：{task.priority}')
        time.sleep(1)
    print('生产者结束')

然后，我们需要定义一个消费者函数 consumer，用于从队列中取出并处理任务：

def consumer(consumer_id: int, q: queue.PriorityQueue):
    while True:
        task = q.get()[1]
        print(f'消费者-{consumer_id} 处理任务：{task.data}，优先级：{task.priority}')
        time.sleep(1)

将生产者和消费者加入线程：

threads = []

q = queue.PriorityQueue()

for i in range(3):
    t = threading.Thread(target=consumer, args=(i, q))
    t.start()
    threads.append(t)

t = threading.Thread(target=producer, args=(q,))
t.start()
threads.append(t)

等待所有线程完成：

for t in threads:
    t.join()

输出结果如下：

生产者-0 生成任务：Task 0-0，优先级：9
生产者-2 生成任务：Task 2-0，优先级：9
消费者-0 处理任务：Task 0-0，优先级：9
消费者-1 处理任务：Task 2-0，优先级：9
生产者-0 生成任务：Task 0-1，优先级：1
生产者-1 生成任务：Task 1-0，优先级：3
消费者-2 处理任务：Task 0-1，优先级：1
生产者-0 生成任务：Task 0-2，优先级：0
生产者-1 生成任务：Task 1-1，优先级：2
生产者-1 生成任务：Task 1-2，优先级：3
生产者-2 生成任务：Task 2-1，优先级：3
消费者-0 处理任务：Task 1-0，优先级：3
消费者-2 处理任务：Task 0-2，优先级：0
消费者-1 处理任务：Task 1-1，优先级：2
消费者-1 处理任务：Task 1-2，优先级：3
消费者-0 处理任务：Task 2-1，优先级：3
生产者-2 生成任务：Task 2-2，优先级：1
消费者-1 处理任务：Task 2-2，优先级：1
生产者-0 生成任务：Task 0-3，优先级：4
消费者-2 处理任务：Task 0-3，优先级：4
生产者-1 生成任务：Task 1-3，优先级：6
消费者-0 处理任务：Task 1-3，优先级：6
生产者-0 生成任务：Task 0-4，优先级：2
生产者-2 生成任务：Task 2-3，优先级：9
消费者-1 处理任务：Task 0-4，优先级：2
生产者结束
消费者-2 处理任务：Task 2-3，优先级：9
消费者-0 结束
消费者-1 结束

以上就是线程优先级队列的详细讲解和使用示例。