66

我们正在尝试建立一个基本的定向队列系统，其中生产者将生成多个任务，而一个或多个消费者将一次获取一个任务，处理它并确认消息。

问题是，处理可能需要 10-20 分钟，而我们当时没有响应消息，导致服务器断开我们的连接。

这是我们消费者的一些伪代码：

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

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

channel.queue_declare(queue='task_queue', durable=True)
print ' [*] Waiting for messages. To exit press CTRL+C'

def callback(ch, method, properties, body):
    long_running_task(connection)
    ch.basic_ack(delivery_tag = method.delivery_tag)

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

channel.start_consuming()

第一个任务完成后，在 BlockingConnection 深处的某个地方抛出异常，抱怨套接字被重置。此外，RabbitMQ 日志显示消费者因未及时响应而断开连接（为什么它重置连接而不是发送 FIN 很奇怪，但我们不会担心）。

我们搜索了很多，因为我们认为这是 RabbitMQ 的正常用例（有很多长时间运行的任务，应该在许多消费者之间分配），但似乎没有其他人真正遇到过这个问题。最后，我们偶然发现了一个线程，建议使用心跳并long_running_task()在单独的线程中生成心跳。

于是代码变成了：

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

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

channel.queue_declare(queue='task_queue', durable=True)
print ' [*] Waiting for messages. To exit press CTRL+C'

def thread_func(ch, method, body):
    long_running_task(connection)
    ch.basic_ack(delivery_tag = method.delivery_tag)

def callback(ch, method, properties, body):
    threading.Thread(target=thread_func, args=(ch, method, body)).start()

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

channel.start_consuming()

这似乎有效，但它非常混乱。我们确定ch对象是线程安全的吗？此外，假设long_running_task()使用该连接参数将任务添加到新队列（即，这个漫长过程的第一部分已经完成，让我们将任务发送到第二部分）。因此，线程正在使用该connection对象。那个线程安全吗？

更重要的是，这样做的首选方式是什么？我觉得这很混乱，可能不是线程安全的，所以也许我们做得不对。谢谢！

4

7 回答 7

34

现在，你最好的办法是关闭心跳，如果你阻塞太久，这将阻止 RabbitMQ 关闭连接。我正在试验 pika 的核心连接管理和在后台线程中运行的 IO 循环，但它不够稳定，无法发布。

在pika v1.1.0这是ConnectionParameters(heartbeat=0)

于 2013-04-22T19:29:18.107 回答
21

请不要禁用心跳！

从 Pika 开始0.12.0，请使用此示例代码中描述的技术在单独的线程上运行长时间运行的任务，然后确认来自该线程的消息。

注意： RabbitMQ 团队会监控邮件列表，rabbitmq-users有时只会在 StackOverflow 上回答问题。

于 2018-10-23T14:46:47.363 回答
11

我遇到了同样的问题。
我的解决方案是：

  1. 关闭服务器端的心跳
  2. 评估任务可能花费的最长时间
  3. 将客户端心跳超时设置为从第 2 步获得的时间

为什么这个？

当我测试以下情况时：

案例一
  1. 服务器心跳开启，1800s
  2. 客户未设置

任务运行很长时间仍然报错 -->1800

案例二
  1. 关闭服务器心跳
  2. 关闭客户端心跳

客户端没有错误，除了一个问题——当客户端崩溃（我的操作系统因某些故障重新启动）时，仍然可以在 Rabbitmq 管理插件中看到 tcp 连接。这令人困惑。

案例三
  1. 关闭服务器心跳
  2. 打开客户端心跳，将其设置为可预见的最大运行时间

在这种情况下，我可以动态更改单个客户端上的每个热点。事实上，我在经常崩溃的机器上设置了心跳。此外，我可以通过Rabbitmq Manangement插件看到离线机器。

环境

操作系统：centos x86_64
pika：0.9.13
rabbitmq：3.3.1

于 2014-05-29T11:17:49.970 回答
8
  1. connection.process_data_events()您可以在您的中定期调用long_running_task(connection)，该函数在被调用时会向服务器发送心跳，并使 pika 客户端远离关闭。
  2. connection.process_data_events()在你的 pika 中设置大于 call period 的 heartbeat 值BlockingConnection。
于 2018-05-08T08:34:19.413 回答
7

不要禁用心跳。
最好的解决方案是在单独的线程中运行任务，并将 设置prefetch_count为1以便消费者使用类似这样的东西只获得 1 条未确认的消息channel.basic_qos(prefetch_count=1)

于 2017-08-16T07:09:32.343 回答
0

您还可以设置一个新线程，在这个新线程中处理消息，并在该线程.sleep处于活动状态时调用连接以防止丢失心跳。这是从 github 中的@gmr 获取的示例代码块，以及指向该问题的链接以供将来参考。

import re
import json
import threading

from google.cloud import bigquery
import pandas as pd
import pika
from unidecode import unidecode

def process_export(url, tablename):
    df = pd.read_csv(csvURL, encoding="utf-8")
    print("read in the csv")
    columns = list(df)
    ascii_only_name = [unidecode(name) for name in columns]
    cleaned_column_names = [re.sub("[^a-zA-Z0-9_ ]", "", name) for name in ascii_only_name]
    underscored_names = [name.replace(" ", "_") for name in cleaned_column_names]
    valid_gbq_tablename = "test." + tablename
    df.columns = underscored_names

    # try:
    df.to_gbq(valid_gbq_tablename, "some_project", if_exists="append", verbose=True, chunksize=10000)
    # print("Finished Exporting")
    # except Exception as error:
    #     print("unable to export due to: ")
    #     print(error)
    #     print()

def data_handler(channel, method, properties, body):
    body = json.loads(body)

    thread = threading.Thread(target=process_export, args=(body["csvURL"], body["tablename"]))
    thread.start()
    while thread.is_alive():  # Loop while the thread is processing
        channel._connection.sleep(1.0)
    print('Back from thread')
    channel.basic_ack(delivery_tag=method.delivery_tag)


def main():
    params = pika.ConnectionParameters(host='localhost', heartbeat=60)
    connection = pika.BlockingConnection(params)
    channel = connection.channel()
    channel.queue_declare(queue="some_queue", durable=True)
    channel.basic_qos(prefetch_count=1)
    channel.basic_consume(data_handler, queue="some_queue")
    try:
        channel.start_consuming()
    except KeyboardInterrupt:
        channel.stop_consuming()
    channel.close()

if __name__ == '__main__':
    main()

链接： https ://github.com/pika/pika/issues/930#issuecomment-360333837

于 2019-02-21T12:54:41.413 回答
0

这是使用线程处理此问题的一种更简单的方法。如果消费者应用程序在当前作业完成之前不应使用另一个作业，则特别有用。ack 可以随时发送——在这种情况下，我选择仅在工作完成时发送它（线程不再活动）。

在自己的线程中启动长时间运行的进程，然后通过调用 channel.process_data_events() 在循环中监视该线程。在主线程中保留对连接对象的引用，因为它不是线程安全的。本质上：

import time
import pika
from threading import Thread
from functools import partial

rmqconn = pika.BlockingConnection( ... )
rmqchan = rmqconn.channel()
rmqchan.basic_consume(
    queue='test',
    on_message_callback=partial(launch_process,rmqconn)
)
rmqchan.start_consuming()

def launch_process(conn,ch,method,properties,body):
    runthread = Thread(target=run_process,args=body)
    runthread.start()
    while runthread.is_alive():
        time.sleep(2)
        conn.process_data_events()
    ch.basic_ack(delivery_tag=method.delivery_tag)

def run_process(body):
    #do the long-running thing
    time.sleep(10)
于 2021-06-24T21:07:23.420 回答