如何在RabbitMQ队列空时停止Pika消费，继续执行后续逻辑？

我编写了一段从RabbitMQ队列获取消息的简单Python代码，但代码会一直等待新消息。请问如何在获取完队列中所有消息后，让程序继续执行后续逻辑？

用户提供的原始代码：

import pika, sys, os

def main():
    connection = pika.BlockingConnection(pika.ConnectionParameters('localhost',credentials=pika.PlainCredentials('user','pass')))
    channel = connection.channel()

    channel.queue_declare(queue='test')

    def callback(ch, method, properties, body):
        print(f" [x] Received {body}")

    channel.basic_consume(queue='sms', on_message_callback=callback, auto_ack=True)

    print(' [*] Waiting for messages. To exit press CTRL+C')
    channel.start_consuming()

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        print('Interrupted')
        try:
            sys.exit(0)
        except SystemExit:
            os._exit(0)

方法1：使用basic_get循环获取消息 #

basic_get会单次从队列中拉取一条消息，当队列无剩余消息时返回None。通过循环调用该方法，直到获取不到消息即可终止消费，继续执行后续逻辑。

修改后的代码示例：

import pika, sys, os

def main():
    connection = pika.BlockingConnection(pika.ConnectionParameters('localhost',credentials=pika.PlainCredentials('user','pass')))
    channel = connection.channel()

    # 确保目标队列存在
    channel.queue_declare(queue='sms')

    def process_message(body):
        print(f" [x] Received {body}")

    print(' [*] Processing existing messages...')
    while True:
        # 拉取消息并自动确认
        method_frame, header_frame, body = channel.basic_get(queue='sms', auto_ack=True)
        if method_frame is None:
            # 队列已空，退出循环
            print(' [*] No more messages in queue. Continuing...')
            break
        process_message(body)

    # 在这里编写后续逻辑
    print(' [*] Executing post-processing tasks...')

    connection.close()

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        print('Interrupted')
        try:
            sys.exit(0)
        except SystemExit:
            os._exit(0)

方法2：basic_consume配合手动停止消费 #

如果偏好回调模式，可以先获取队列当前的消息总数，在回调中计数，当处理完所有初始消息后调用channel.stop_consuming()终止监听。

注意：该方式仅处理获取消息数时队列中已有的消息，后续新增的消息不会被处理。

修改后的代码示例：

import pika, sys, os

def main():
    connection = pika.BlockingConnection(pika.ConnectionParameters('localhost',credentials=pika.PlainCredentials('user','pass')))
    channel = connection.channel()

    # 被动声明队列并获取当前消息数量
    queue_result = channel.queue_declare(queue='sms', passive=True)
    total_messages = queue_result.method.message_count
    processed_count = 0

    def callback(ch, method, properties, body):
        nonlocal processed_count
        print(f" [x] Received {body}")
        processed_count += 1
        # 处理完所有初始消息后停止消费
        if processed_count >= total_messages:
            ch.stop_consuming()

    if total_messages > 0:
        channel.basic_consume(queue='sms', on_message_callback=callback, auto_ack=True)
        print(' [*] Processing messages...')
        channel.start_consuming()
    else:
        print(' [*] No messages in queue.')

    # 在这里编写后续逻辑
    print(' [*] Executing post-processing tasks...')

    connection.close()

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        print('Interrupted')
        try:
            sys.exit(0)
        except SystemExit:
            os._exit(0)

关键注意点 #

• 方法1为轮询拉取，适合仅处理当前队列存量消息的场景，无需持续监听新消息。
• 方法2若需处理后续新增消息，请勿使用该计数停止的逻辑，保持原有的start_consuming()即可。
• 无论哪种方法，都要确保在程序结束前关闭RabbitMQ连接，避免资源泄漏。

内容的提问来源于stack exchange，提问作者Boaz Lowenstein