queue模块：消息安全地在多线程间交换，实现了多生产者、多消费者队列

看源码 queue 模块包含四个实用的类：

一、三种队列：

1、Queue()、SimpleQueue()：先进先出队列

import heapq

def simulate_message_queue():
    # 读取输入
    message_line = input().strip().split()
    consumer_line = input().strip().split()
    
    # 解析发布者的消息
    messages = []
    for i in range(0, len(message_line), 2):
        time = int(message_line[i])
        content = int(message_line[i + 1])
        messages.append((time, content))
    
    # 解析消费者的订阅和取消订阅
    consumers = []
    for i in range(0, len(consumer_line), 2):
        subscribe_time = int(consumer_line[i])
        unsubscribe_time = int(consumer_line[i + 1])
        consumers.append((subscribe_time, unsubscribe_time, i // 2))  # 消费者编号为i//2
    
    # 收集所有事件
    events = []
    for time, content in messages:
        events.append((time, 'message', content))
    for sub_time, unsub_time, consumer_id in consumers:
        events.append((sub_time, 'subscribe', consumer_id))
        events.append((unsub_time, 'unsubscribe', consumer_id))
    
    # 按时间排序事件，同一时刻的事件按订阅、取消订阅、消息的顺序处理
    events.sort(key=lambda x: (x[0], 0 if x[1] == 'subscribe' else (1 if x[1] == 'unsubscribe' else 2)))
    
    # 当前订阅的消费者，使用最小堆模拟最大优先级队列（优先级是负数）
    active_consumers = []
    consumer_messages = [[] for _ in range(len(consumers))]
    
    for event in events:
        time, event_type, data = event
        if event_type == 'subscribe':
            consumer_id = data
            # 使用负数模拟最大堆，因为消费者按优先级升序排列
            heapq.heappush(active_consumers, (-consumer_id, consumer_id))
        elif event_type == 'unsubscribe':
            consumer_id = data
            # 需要从堆中移除该消费者，这里简化处理，假设取消订阅时消费者一定在堆顶
            if active_consumers and active_consumers[0][1] == consumer_id:
                heapq.heappop(active_consumers)
            else:
                # 如果消费者不在堆顶，需要遍历整个堆来移除
                temp = []
                found = False
                while active_consumers:
                    item = heapq.heappop(active_consumers)
                    if item[1] == consumer_id:
                        found = True
                        break
                    temp.append(item)
                if not found:
                    for item in temp:
                        heapq.heappush(active_consumers, item)
        elif event_type == 'message':
            if active_consumers:
                # 获取优先级最高的消费者
                _, consumer_id = active_consumers[0]
                consumer_messages[consumer_id].append(data)
    
    # 输出结果
    for messages in consumer_messages:
        if messages:
            print(' '.join(map(str, messages)))
        else:
            print(-1)

simulate_message_queue()

进程彼此之间互相隔离，要实现进程间通信（IPC），multiprocessing模块支持两种形式：队列和管道(不推荐使用)，这两种方式都是使用消息传递的

选自towardsdatascience

作者：Farhad Malik

机器之心编译

编辑：陈萍

Python中的队列源代码位于 lib/queue.py 「链接」中

前言

上篇文章介绍了 Python 中的多线程。今天来介绍下编程中常会用到的一个数据结构 - 队列。

不知道大家是否还记得什么是数据结构呢？在很早很早以前，Python小课堂的初期，讲了许多 Python 原生的数据结构。比如 list、tuple、dict 等。。。

既然叫数据结构，实际上就是为了给计算机存储数据用的一种结构体。不同的数据结构都有其不同的特点。那今天就来简单地聊聊队列！