更新

Question

我正在构建一个系统，其中生产者发送一个要排队的任务列表，这些任务将由许多消费者使用。

假设我有一个任务列表，它们可以分为黑色，橙色和黄色。所有Black任务都被发送到Queue_0，Orange到Queue_1和Yellow到Queue_2。我将为每个队列分配一个worker（即：Consumer_0到Queue_0，Consumer_1到Queue_1，Consumer_2到Queue_2）。如果黑名单变大，我想在Queue_0中添加一个额外的消费者（即：Consumer_3）以帮助消费者_0。

我在Worker Queues和Routing上浏览了RabbitMQ教程。我以为路由会解决我的问题。我推出了三个终端，一个制作人和两个将接收黑色任务的消费者。当生产者发送一些黑色任务（Black_Task_1，Black_Task_2）时，两个消费者都收到了两条消息（即：Consumer_0接收Black_Task_1和Black_Task_2，Consumer_3也接收Black_Task_1和Black_Task_2）。我希望我的消费者分享任务，而不是做同样的任务。例如，Consumer_0执行Black_Task_1，而Consumer_3执行Black_Task_2。我可以实现哪些配置？

=============================

更新

这是一个取自RabbitMQ路由教程的示例代码。我修改了一下。请注意，此代码不会发送黑色，橙色或黄色队列。但这个概念就在那里。

emit_log_direct.py

#!/usr/bin/env python
import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_logs',
                         type='direct')

severity = sys.argv[1] if len(sys.argv) > 1 else 'info'
message = ' '.join(sys.argv[2:]) or 'Hello World!'
channel.basic_publish(exchange='direct_logs',
                      routing_key=severity,
                      body=message)
print " [x] Sent %r:%r" % (severity, message)
connection.close()

receive_logs_direct.py

#!/usr/bin/env python
import pika
import sys
import time

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_logs',
                         type='direct')

result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue

severities = sys.argv[1:]
if not severities:
    print >> sys.stderr, "Usage: %s [info] [warning] [error]" % \
                         (sys.argv[0],)
    sys.exit(1)

for severity in severities:
    channel.queue_bind(exchange='direct_logs',
                       queue=queue_name,
                       routing_key=severity)

print ' [*] Waiting for logs. To exit press CTRL+C'

def callback(ch, method, properties, body):
    print " [x] %r:%r" % (method.routing_key, body,)
    time.sleep(1)
    print " [x] Done"
    ch.basic_ack(delivery_tag=method.delivery_tag)

channel.basic_qos(prefetch_count=1)
channel.basic_consume(callback,
                      queue=queue_name)

channel.start_consuming()

生产者

nuttynibbles$ ./4_emit_log_direct.py info "run run info"
 [x] Sent 'info':'run run info'

Consumer_0

nuttynibbles$ ./4_receive_logs_direct_customize.py info
 [*] Waiting for logs. To exit press CTRL+C
 [x] 'info':'run run info'
 [x] Done

Consumer_3

nuttynibbles$ ./4_receive_logs_direct_customize.py info
 [*] Waiting for logs. To exit press CTRL+C
 [x] 'info':'run run info'
 [x] Done

Answer 1

我认为你的基本问题是：

如果Black 列表队列变大，我想添加一个额外的Consumer（即： Consumer_3）到Queue_0以帮助Consumer_0。

只要您将另一个消费者添加到队列中，它就会获取下一个可用消息。

如果第一个消费者没有acknowledge the message;然后，多个工作人员将能够处理相同的消息，因为它将保留在队列中。

因此，请确保您正确地确认了这些消息：

默认情况下，RabbitMQ会将每条消息发送给下一个消费者序列。平均而言，每个消费者都会获得相同的数量消息。这种分发消息的方式称为循环法。 [...] 没有任何消息超时; RabbitMQ将重新发送消息只有当工人连接死亡时即使处理a也没关系消息需要非常长的时间。

根据任务的性质，您可以通过创建优先级队列在多个进程之间拆分工作; C ₁ （消费者）使用它来获取额外资源。在这种情况下，您必须准备好工作人员并监听单独的优先级队列;从而创建一个子队列，其中正在处理 T ₁ （一项任务）。

但是，在其他方面，初始 C ₁ 必须通过确认收到任务来确保该任务不再可用。

Answer 2

我认为您的问题是您正在为每个消费者创建一个新的队列。当你打电话

result = channel.queue_declare（exclusive = True）

queue_name = result.method.queue

在您的消费者中，这声明了一个新队列，告诉RabbitMQ为它生成一个唯一的名称，并将其标记为供调用它的消费者中的通道独占使用。这意味着每个消费者都有自己的队列。

然后使用严重性作为路由密钥将每个新队列绑定到交换机。当消息进入直接Exchange时，RabbitMQ会将其副本路由到与匹配的路由密钥绑定的每个Queue。队列中没有循环。每个消费者都会得到一条消息副本，这正是您所观察到的。

我相信你想要做的是让每个消费者对队列使用相同的名称，在queue_declare中指定名称，而不是使其独占。然后所有消费者都将收听同一个队列。这些消息将以循环方式传递给其中一个消费者。

生产者（emit_log.py程序）不会声明或绑定队列 - 它不必，但如果在发送消息之前没有建立绑定，它将被丢弃。如果您使用固定队列，也可以让生产者设置它，只需确保使用与消费者相同的参数（例如queue_name）。

RabbitMQ - 结合工作队列和路由队列

更新

2 个答案: