Python和RabbitMQ—侦听来自多个通道的消费事件的最佳方式？

我有两个单独的RabbitMQ实例。我正试图找到最好的方式来聆听双方的事件

例如，我可以使用具有以下内容的事件：

credentials = pika.PlainCredentials(user, pass)
connection = pika.BlockingConnection(pika.ConnectionParameters(host="host1", credentials=credentials))
channel = connection.channel()
result = channel.queue_declare(Exclusive=True)
self.channel.queue_bind(exchange="my-exchange", result.method.queue, routing_key='*.*.*.*.*')
channel.basic_consume(callback_func, result.method.queue, no_ack=True)
self.channel.start_consuming()

我还有第二个主持人“host2”，我也想听听。我想创建两个独立的线程来实现这一点，但从我所读到的来看，pika不是线程安全的。有更好的办法吗？或者创建两个单独的线程，每个线程监听一个不同的兔子实例（host1和host2）就足够了吗？

关于“最佳方式”的答案很大程度上取决于队列的使用模式以及“最佳”的含义。由于我还不能对问题发表评论，我将尝试提出一些可能的解决方案

在每个示例中，我将假设exchange已经声明

线程 您可以在单个进程中使用来自不同主机上的两个队列的消息

您是对的，

pika

不是线程安全的，但它可以通过为每个线程创建到RabbitMQ主机的连接以多线程方式使用。使用模块在线程中运行此示例如下所示：

import pika
import threading


class ConsumerThread(threading.Thread):
    def __init__(self, host, *args, **kwargs):
        super(ConsumerThread, self).__init__(*args, **kwargs)

        self._host = host

    # Not necessarily a method.
    def callback_func(self, channel, method, properties, body):
        print("{} received '{}'".format(self.name, body))

    def run(self):
        credentials = pika.PlainCredentials("guest", "guest")

        connection = pika.BlockingConnection(
            pika.ConnectionParameters(host=self._host,
                                      credentials=credentials))

        channel = connection.channel()

        result = channel.queue_declare(exclusive=True)

        channel.queue_bind(result.method.queue,
                           exchange="my-exchange",
                           routing_key="*.*.*.*.*")

        channel.basic_consume(self.callback_func,
                              result.method.queue,
                              no_ack=True)

        channel.start_consuming()


if __name__ == "__main__":
    threads = [ConsumerThread("host1"), ConsumerThread("host2")]
    for thread in threads:
        thread.start()

我已经声明了

callback\u func

作为一种方法，在打印消息正文时纯粹使用

ConsumerThread.name

。它也可能是

ConsumerThread

类之外的函数

过程 或者，对于要使用事件的每个队列，始终可以使用使用者代码运行一个进程

import pika
import sys


def callback_func(channel, method, properties, body):
    print(body)


if __name__ == "__main__":
    credentials = pika.PlainCredentials("guest", "guest")

    connection = pika.BlockingConnection(
        pika.ConnectionParameters(host=sys.argv[1],
                                  credentials=credentials))

    channel = connection.channel()

    result = channel.queue_declare(exclusive=True)

    channel.queue_bind(result.method.queue,
                       exchange="my-exchange",
                       routing_key="*.*.*.*.*")

    channel.basic_consume(callback_func, result.method.queue, no_ack=True)

    channel.start_consuming()

然后由以下人员运行：

$ python single_consume.py host1
$ python single_consume.py host2  # e.g. on another console

如果您对来自队列的消息所做的工作是，并且只要CPU中的内核数>=使用者数，通常最好使用这种方法-除非您的队列大部分时间是空的，并且使用者不会利用此CPU时间*

异步的 另一种选择是涉及一些异步框架（例如），并在单个线程中运行整个过程

您不能再在异步代码中使用

BlockingConnection

；幸运的是，

pika

有用于

Twisted

的适配器：

from pika.adapters.twisted_connection import TwistedProtocolConnection
from pika.connection import ConnectionParameters
from twisted.internet import protocol, reactor, task
from twisted.python import log


class Consumer(object):
    def on_connected(self, connection):
        d = connection.channel()
        d.addCallback(self.got_channel)
        d.addCallback(self.queue_declared)
        d.addCallback(self.queue_bound)
        d.addCallback(self.handle_deliveries)
        d.addErrback(log.err)

    def got_channel(self, channel):
        self.channel = channel

        return self.channel.queue_declare(exclusive=True)

    def queue_declared(self, queue):
        self._queue_name = queue.method.queue

        self.channel.queue_bind(queue=self._queue_name,
                                exchange="my-exchange",
                                routing_key="*.*.*.*.*")

    def queue_bound(self, ignored):
        return self.channel.basic_consume(queue=self._queue_name)

    def handle_deliveries(self, queue_and_consumer_tag):
        queue, consumer_tag = queue_and_consumer_tag
        self.looping_call = task.LoopingCall(self.consume_from_queue, queue)

        return self.looping_call.start(0)

    def consume_from_queue(self, queue):
        d = queue.get()

        return d.addCallback(lambda result: self.handle_payload(*result))

    def handle_payload(self, channel, method, properties, body):
        print(body)


if __name__ == "__main__":
    consumer1 = Consumer()
    consumer2 = Consumer()

    parameters = ConnectionParameters()
    cc = protocol.ClientCreator(reactor,
                                TwistedProtocolConnection,
                                parameters)
    d1 = cc.connectTCP("host1", 5672)
    d1.addCallback(lambda protocol: protocol.ready)
    d1.addCallback(consumer1.on_connected)
    d1.addErrback(log.err)

    d2 = cc.connectTCP("host2", 5672)
    d2.addCallback(lambda protocol: protocol.ready)
    d2.addCallback(consumer2.on_connected)
    d2.addErrback(log.err)

    reactor.run()

这种方法会更好，您从中消耗的队列越多，消费者执行的工作受到的CPU限制就越少*

Python 3 由于您提到了

pika

，我将自己局限于基于python2.x的解决方案，因为

pika

尚未移植

但是，如果您想转到>=3.3，一个可能的选项是与AMQP协议（您与RabbitMQ交谈的协议）之一一起使用，例如，或

---

*-请注意，这些都是非常肤浅的提示-在大多数情况下，选择不是那么明显；什么对您最有利取决于队列“饱和”（消息/时间）、您在收到这些消息时做什么工作、您在什么环境中运行您的消费者等。；除了对所有实现进行基准测试之外，没有其他方法可以确定

下面是我如何使用一个rabbitmq实例同时侦听两个队列的示例：

import pika
import threading

threads=[]
def client_info(channel):    
   channel.queue_declare(queue='proxy-python')
   print (' [*] Waiting for client messages. To exit press CTRL+C')


   def callback(ch, method, properties, body):
       print (" Received %s" % (body))

   channel.basic_consume(callback, queue='proxy-python', no_ack=True)
   channel.start_consuming()

def scenario_info(channel):    
   channel.queue_declare(queue='savi-virnet-python')
   print (' [*] Waiting for scenrio messages. To exit press CTRL+C')


   def callback(ch, method, properties, body):
      print (" Received %s" % (body))

   channel.basic_consume(callback, queue='savi-virnet-python', no_ack=True)
   channel.start_consuming()

def manager():
   connection1= pika.BlockingConnection(pika.ConnectionParameters
  (host='localhost'))
   channel1 = connection1.channel()
  connection2= pika.BlockingConnection(pika.ConnectionParameters
  (host='localhost'))
   channel2 = connection2.channel()
   t1 = threading.Thread(target=client_info, args=(channel1,))
   t1.daemon = True
   threads.append(t1)
   t1.start()  

   t2 = threading.Thread(target=scenario_info, args=(channel2,))
   t2.daemon = True
   threads.append(t2)


   t2.start()
   for t in threads:
     t.join()


 manager()

您可以异步使用aio pika 这里有更多的例子

---

快乐编码：）

Hi@Unit03我知道你在2015年已经回答了。我使用的是同一个扭曲的适配器，我丢失了太多的心跳。您可以访问我的问题以获取代码和更多说明。嗨，瓦伊巴夫，我已经回答了这个问题。

import asyncio
import tornado.ioloop
import tornado.web

from aio_pika import connect_robust, Message

tornado.ioloop.IOLoop.configure("tornado.platform.asyncio.AsyncIOLoop")
io_loop = tornado.ioloop.IOLoop.current()
asyncio.set_event_loop(io_loop.asyncio_loop)

QUEUE = asyncio.Queue()


class SubscriberHandler(tornado.web.RequestHandler):
    async def get(self):
        message = await QUEUE.get()
        self.finish(message.body)


class PublisherHandler(tornado.web.RequestHandler):
    async def post(self):
        connection = self.application.settings["amqp_connection"]
        channel = await connection.channel()
        try:
            await channel.default_exchange.publish(
                Message(body=self.request.body), routing_key="test",
            )
        finally:
            await channel.close()
            print('ok')
        self.finish("OK")

async def make_app():
    amqp_connection = await connect_robust()
    channel = await amqp_connection.channel()
    queue = await channel.declare_queue("test", auto_delete=True)
    await queue.consume(QUEUE.put, no_ack=True)
    return tornado.web.Application(
        [(r"/publish", PublisherHandler), (r"/subscribe", SubscriberHandler)],
        amqp_connection=amqp_connection,
    )

if __name__ == "__main__":
    app = io_loop.asyncio_loop.run_until_complete(make_app())
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()