Question

我是RabbitMQ的新手，我正在尝试创建一个具有3个角色的应用程序：两个生产者和一个消费者。消费者与两个与两个生产者有关的队列有关。每个生产者以不同的频率将消息发送到队列。我需要的是消费者从两个生产者那里交替阅读。

例如：

制作人1：每2秒发送一次“ Hello” 制作人2：每5秒钟发送一次“世界” 消费者：打印收到的任何东西

因此，希望消费者打印：

hello world hello world hello world ...

由于生产者1比生产者2发送消息的频率更高，因此，在消费者从消费者1读取信息之后，它需要稍等片刻，等待来自生产者2的消息到达（这就是问题所在）

我试图为生产者声明两个队列，并将它们链接到消费者，但是消费者只打印以下内容：

你好，你好，世界

感谢您的帮助！

更新：这是我的代码

制作人1：

import pika
import sys

message = 'hello'


credentials = pika.PlainCredentials('xxxx', 'xxxx)
connection =pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, '/', credentials))
channel = connection.channel()
channel.queue_declare(queue='hello')

while True:
    channel.basic_publish(exchange='', routing_key='hello', body=message)
    print('Sent message: {}'.format(message))
    connection.sleep(2)

connection.close()

制作人2：

import pika
import sys

message = 'world'


credentials = pika.PlainCredentials('xxxx', 'xxxx')
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, '/', credentials))
channel = connection.channel()


channel.queue_declare(queue='world')

while True:
    channel.basic_publish(exchange='', routing_key='world', body=message)
    print('Sent message: {}'.format(message))
    connection.sleep(4)

connection.close()

消费者1：

import pika

def callback(ch, method, properties, body):
    print('Receive: {}'.format(body))


credentials = pika.PlainCredentials('xxxx', 'xxxx')
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, '/', credentials))
channel = connection.channel()
channel.basic_qos(prefetch_count=1)
channel.queue_declare(queue='hello')
channel.queue_declare(queue='world')

channel.basic_consume(on_message_callback=callback, queue='hello', auto_ack=True)
channel.basic_consume(on_message_callback=callback, queue='world', auto_ack=True)
print('Waiting for messages. To exit press CTRL+C')


channel.start_consuming()

Answer 1

由于使用者只能从一个队列中消费，因此您必须确保所有消息都路由到该队列。

然后由消费者来处理消息。它必须使用轮询API来获取一条消息。根据哪个消费者发布每个消息，消费者将不得不采取不同的行动。它可以保留来自生产者1的消息的本地存储，该本地存储是在对来自生产者2的消息执行操作之前到达的。消费者将延迟对其存储在该存储中的消息的操作，直到对来自生产者2的消息进行了操作为止。只有这样，它才会从该商店中获取第一条消息并对其执行操作。

编辑：

在您添加到问题中的代码中，您只有一个渠道（很好），但是有两个使用者，每次调用{{1} }。两个使用者都使用相同的回调方法channel.basic_consume。正是这种方法必须实现我上面描述的逻辑。

单个消费者从多个队列中交替阅读

1 个答案: